DEV Community: DHANRAJ S

Java Interface

DHANRAJ S — Mon, 15 Jun 2026 18:47:05 +0000

today we discuss about Interface in Java.
first we understand the concept with simple Analogy,

Imagine you go to a shop and buy items.

in a bill counter, the shop keeper care about only one thing.
The customer paid the Money or not.

The shopkeeper does NOT care about how you pay the money,

UPI
Debit Card
Cash

They only thing is payment paid in successfully.

Here a interface acts like a Rule in billing counter.
It only defines what must be done, not how it should be done.

Different payment methods follow the same rule, but each one works in its own way.

The shopkeeper does not need to change anything in the billing counter.

No matter how the customer pays, the system works the same.

so, i follow this analogy and using a example for this blog.

What is Interface? (in GeeksforGeeks)

An interface in Java is a blueprint that defines a set of methods a class must implement without providing full implementation details. It helps achieve abstraction by focusing on what a class should do rather than how it does it. Interfaces also support multiple inheritance in Java.

A class must implement all abstract methods of an interface.
All variables in an interface are public, static, and final by default.
Interfaces can have default, static, and private methods

first create a interface file Payment.java

public interface Payment {
    void pay(int amount);
}

here we create a method but not defined that method

This is the shop rule.

“Anyone wants to pay must follow one rule → pay the amount.”

The shop does not explain how you pay, only thing is you must pay.

next we create another file for Different Customers,

class CardPayment implements Payment {
    public void pay(int amount) {
        System.out.println("Paid ₹" + amount + " using Card");
    }
}

class UpiPayment implements Payment {
    public void pay(int amount) {
        System.out.println("Paid ₹" + amount + " using UPI");
    }
}

class CashPayment implements Payment {
    public void pay(int amount) {
        System.out.println("Paid ₹" + amount + " using Cash");
    }
}

java

These are the different methods for customers can pay:

One customer uses Card
One uses UPI
One uses Cash

Each customer follows the same rule, but pays in a different way.

The objects for represent real customers standing at the counter with their payment method.

One customer using card
One customer using UPI
One customer using cash

so next we create a class for PaymentApp,
how the customer pay the amount in the counter.

public class PaymentApp {

    public static void processPayment(Payment payment, int amount) {
        payment.pay(amount);
    }

    public static void main(String[] args) {

        CardPayment card = new CardPayment();
        UpiPayment upi = new UpiPayment();
        CashPayment cash = new CashPayment();

        processPayment(card, 2500);
        processPayment(upi, 1200);
        processPayment(cash, 500);
    }
}

plaintext

The processPayment method is the billing counter.

Here the counter says:

“I don’t care how you pay.
Just give me something that follows the payment rule.”

Because of this:

Card works
UPI works
Cash works

Next the Main is

One customer pays ₹2500 using card
Another pays ₹1200 using UPI
Another pays ₹500 using cash

The same counter handles all payments without any change.

Shop does not change for new payment methods,

Tomorrow, if a new customer pays using Wallet, the shop still works.

here i will show you the o/p,

user@boss:~/Desktop/java$ javac Payment.java 
user@boss:~/Desktop/java$ javac PaymentService.java 
user@boss:~/Desktop/java$ javac PaymentApp.java 
user@boss:~/Desktop/java$ java PaymentApp
Paid ₹2500 using Card
Paid ₹1200 using UPI
Paid ₹500 using Cash

What we understand today

The interface is like a shop rule, and different payment methods follow that rule in their own way.

Python While Loop Programs — Divisors, Primes, Factorial and More

DHANRAJ S — Sat, 06 Jun 2026 17:54:39 +0000

Hey!

Welcome back.

In the last blog — we covered patterns, multiples, and divisors using while loops.

Today we go deeper.

Prime numbers. Perfect numbers. Factorial. Odd and even in one loop. Sum programs. All using only while loops.

Each program builds your thinking. By the end — you will be very comfortable writing loops with conditions.

Let us start.

1. Prime Number

A prime number is a number that has exactly 2 divisors — 1 and itself.

2, 3, 5, 7, 11, 13 are prime numbers.
4, 6, 8, 9, 10 are not — they have more than 2 divisors.

Quick question for you.

Is 1 a prime number?

No. 1 has only one divisor — itself. A prime number needs exactly 2 divisors. So 1 is not prime.

The logic — count divisors. If count is exactly 2 — it is prime.

n = int(input("Enter a number: "))

i = 1
count = 0

while i <= n:
    if n % i == 0:
        count += 1
    i += 1

if count == 2:
    print(n, "is a Prime Number")
else:
    print(n, "is NOT a Prime Number")

Input: 7

Output:

7 is a Prime Number

Input: 12

Output:

12 is NOT a Prime Number

Input: 1

Output:

1 is NOT a Prime Number

The logic is clean — count the divisors. Two divisors means prime. Anything else means not prime.

2. Perfect Number

A perfect number is a number where the sum of all its divisors (except itself) equals the number.

Example — 6. Divisors of 6 (excluding 6) are 1, 2, 3. Sum = 1 + 2 + 3 = 6. Equal to the number. So 6 is perfect.

Example — 28. Divisors of 28 (excluding 28) are 1, 2, 4, 7, 14. Sum = 1+2+4+7+14 = 28. Perfect.

Quick question for you.

Why do we exclude the number itself when checking for a perfect number?

Because if we include it — every number would have its divisor sum exceed itself. The definition of perfect number specifically means the sum of proper divisors — all divisors except the number itself.

n = int(input("Enter a number: "))

i = 1
total = 0

while i <= n//2:       
    if n % i == 0:
        total += i
    i += 1

if total == n:
    print(n, "is a Perfect Number")
else:
    print(n, "is NOT a Perfect Number")

Input: 6

Output:

6 is a Perfect Number

Input: 28

Output:

28 is a Perfect Number

Input: 10

Output:

10 is NOT a Perfect Number

Notice while i <= n//2 — not i <= n. We stop before reaching the number itself so we never include it in the sum.

3. Print 1 3 5 7 9 2 4 6 8 10 — Odd Then Even in a Single Loop

Print all odd numbers from 1 to 9, then all even numbers from 2 to 10 — in a single loop.

Quick question for you.

Think about this before reading the code. How would you print odd and even numbers in one loop?

The trick — run the loop 10 times. In the first 5 steps, print odd. In the next 5 steps, print even.

i = 1

while i <= 10:
    if i <= 5:
        print(2 * i - 1, end=" ")   # odd numbers: 1 3 5 7 9
    else:
        print(2 * (i - 5), end=" ") # even numbers: 2 4 6 8 10
    i += 1

Output:

1 3 5 7 9 2 4 6 8 10

Let us trace through the logic.

When i = 1 → 2*1 - 1 = 1
When i = 2 → 2*2 - 1 = 3
When i = 3 → 2*3 - 1 = 5
When i = 4 → 2*4 - 1 = 7
When i = 5 → 2*5 - 1 = 9
When i = 6 → 2*(6-5) = 2
When i = 7 → 2*(7-5) = 4
When i = 8 → 2*(8-5) = 6
When i = 9 → 2*(9-5) = 8
When i = 10 → 2*(10-5) = 10

One loop. Both odd and even. Clean.

4. Factorial of a Given Number

Factorial of a number means multiply it with every number below it down to 1.

Factorial of 5 = 5 × 4 × 3 × 2 × 1 = 120

Written as 5!

Factorial of 0 = 1 (by definition)
Factorial of 1 = 1

Quick question for you.

What is 4!?

4 × 3 × 2 × 1 = 24.

n = int(input("Enter a number: "))

i = 1
result = 1

while i <= n:
    result = result * i
    i += 1

print("Factorial of", n, "is:", result)

Input: 5

Output:

Factorial of 5 is: 120

Input: 0

Output:

Factorial of 0 is: 1

When n = 0 — the while loop condition i <= 0 is false immediately. Loop never runs. result stays 1. Which is the correct answer.

Let us trace 5!:

result = 1
i=1 → result = 1 * 1 = 1
i=2 → result = 1 * 2 = 2
i=3 → result = 2 * 3 = 6
i=4 → result = 6 * 4 = 24
i=5 → result = 24 * 5 = 120

5. Sum of First N Numbers

Add all numbers from 1 to n.

Sum of first 5 = 1 + 2 + 3 + 4 + 5 = 15.

n = int(input("Enter n: "))

i = 1
total = 0

while i <= n:
    total += i
    i += 1

print("Sum of first", n, "numbers:", total)

Input: 5

Output:

Sum of first 5 numbers: 15

Input: 10

Output:

Sum of first 10 numbers: 55

total = 0 — starts at zero.
Each step adds i to total.
After the loop — total holds the sum.

Quick question for you.

There is actually a formula for this — n * (n + 1) / 2. For n = 10, that gives 10 * 11 / 2 = 55. Same answer.

So why use a loop?

Because loops are easier to understand and modify. What if you want the sum of only even numbers from 1 to n? The formula does not directly help. The loop does — just add if i % 2 == 0.

6. Print First 5 Prime Numbers

We already know how to check if a number is prime. Now we keep checking numbers one by one until we have found 5 primes.

count = 0
n = 2

while count < 5:
    i = 1
    divisors = 0

    while i <= n:
        if n % i == 0:
            divisors += 1
        i += 1

    if divisors == 2:
        print(n, end=" ")
        count += 1

    n += 1

print()

Output:

2 3 5 7 11

Let us understand the structure.

Outer loop — runs until we have found 5 primes. count < 5.

Inner loop — checks if current n is prime by counting divisors.

If n is prime — print it, increase count.

Move to next number — n += 1.

Two nested while loops. Outer controls how many primes we want. Inner checks if each number is prime.

Quick question for you.

Why do we start n at 2 and not 1?

Because 1 is not a prime number. It has only 1 divisor. Starting at 2 skips 1 naturally. 2 is the smallest prime number.

7. Sum of First 5 Prime Numbers

Same logic as program 14 — but instead of printing, we add each prime to a total.

count = 0
n = 2
total = 0

while count < 5:
    i = 1
    divisors = 0

    while i <= n:
        if n % i == 0:
            divisors += 1
        i += 1

    if divisors == 2:
        total += n
        count += 1

    n += 1

print("Sum of first 5 prime numbers:", total)

Output:

Sum of first 5 prime numbers: 28

First 5 primes are 2, 3, 5, 7, 11. Sum = 2+3+5+7+11 = 28.

The only change from program 14 — instead of print(n) we write total += n. And at the end we print the total.

Quick Summary — What Each Program Teaches

Program	What It Teaches
Count of Divisors	`%` operator, counting with a loop
Prime Number	Divisor count == 2 means prime
Perfect Number	Sum of proper divisors == number
Odd Then Even	Math formula inside loop to generate patterns
Factorial	Multiplying instead of adding in a loop
Sum of N Numbers	Running total using `total += i`
First 5 Primes	Nested loops — outer controls count, inner checks prime
Sum of First 5 Primes	Same as above — add instead of print

The key idea connecting all these programs.

Every problem becomes simple when you break it into steps.

Is this number prime? → Count its divisors. If 2, yes.
Is this number perfect? → Sum its proper divisors. If equal, yes.
What is the factorial? → Multiply while counting down.

The loop just repeats those steps automatically.

Try modifying the programs.

What are the first 10 prime numbers?
What is the factorial of 10?
Sum of first 20 numbers?
Is 496 a perfect number?

Change the numbers. Run the code. Verify your answers.

That hands-on practice is where loops truly click.

If you have a question — drop it in the comments below.

Thanks for reading. Keep building.---
title: Python While Loop Programs — Divisors, Primes, Factorial and More
published: true

tags: python, beginners, programming, loops

Hey!

Welcome back.

In the last blog — we covered patterns, multiples, and divisors using while loops.

Today we go deeper.

Prime numbers. Perfect numbers. Factorial. Odd and even in one loop. Sum programs. All using only while loops.

Each program builds your thinking. By the end — you will be very comfortable writing loops with conditions.

Let us start.

Quick Reminder — How a While Loop Works

i = 1

while i <= 5:
    print(i)
    i += 1

Start somewhere. Check the condition. Run the body. Move forward. Repeat until condition is false.

Every program today follows this same idea.

8. Count of Divisors of a Given Number

A divisor is a number that divides another number exactly — with no remainder.

Divisors of 12 are: 1, 2, 3, 4, 6, 12. So count is 6.

Quick question for you.

How do you check if a number divides another exactly?

Using % — the modulo operator. It gives the remainder.

12 % 3 = 0 → 3 divides 12 exactly. Divisor.
12 % 5 = 2 → 5 does not divide 12 exactly. Not a divisor.

n = int(input("Enter a number: "))

i = 1
count = 0

while i <= n:
    if n % i == 0:
        count += 1
    i += 1

print("Count of divisors:", count)

Input: 12

Output:

Count of divisors: 6

Input: 7

Output:

Count of divisors: 2

7 has only 2 divisors — 1 and 7. That means 7 is a prime number. We will use this idea in the next program.

9. Prime Number

A prime number is a number that has exactly 2 divisors — 1 and itself.

2, 3, 5, 7, 11, 13 are prime numbers.
4, 6, 8, 9, 10 are not — they have more than 2 divisors.

Quick question for you.

Is 1 a prime number?

No. 1 has only one divisor — itself. A prime number needs exactly 2 divisors. So 1 is not prime.

The logic — count divisors. If count is exactly 2 — it is prime.

n = int(input("Enter a number: "))

i = 1
count = 0

while i <= n:
    if n % i == 0:
        count += 1
    i += 1

if count == 2:
    print(n, "is a Prime Number")
else:
    print(n, "is NOT a Prime Number")

Input: 7

Output:

7 is a Prime Number

Input: 12

Output:

12 is NOT a Prime Number

Input: 1

Output:

1 is NOT a Prime Number

The logic is clean — count the divisors. Two divisors means prime. Anything else means not prime.

10. Perfect Number

A perfect number is a number where the sum of all its divisors (except itself) equals the number.

Example — 6. Divisors of 6 (excluding 6) are 1, 2, 3. Sum = 1 + 2 + 3 = 6. Equal to the number. So 6 is perfect.

Example — 28. Divisors of 28 (excluding 28) are 1, 2, 4, 7, 14. Sum = 1+2+4+7+14 = 28. Perfect.

Quick question for you.

Why do we exclude the number itself when checking for a perfect number?

n = int(input("Enter a number: "))

i = 1
total = 0

while i < n:       # notice: i < n, not i <= n
    if n % i == 0:
        total += i
    i += 1

if total == n:
    print(n, "is a Perfect Number")
else:
    print(n, "is NOT a Perfect Number")

Input: 6

Output:

6 is a Perfect Number

Input: 28

Output:

28 is a Perfect Number

Input: 10

Output:

10 is NOT a Perfect Number

Notice while i < n — not i <= n. We stop before reaching the number itself so we never include it in the sum.

11. Print 1 3 5 7 9 2 4 6 8 10 — Odd Then Even in a Single Loop

Print all odd numbers from 1 to 9, then all even numbers from 2 to 10 — in a single loop.

Quick question for you.

Think about this before reading the code. How would you print odd and even numbers in one loop?

The trick — run the loop 10 times. In the first 5 steps, print odd. In the next 5 steps, print even.

i = 1

while i <= 10:
    if i <= 5:
        print(2 * i - 1, end=" ")   # odd numbers: 1 3 5 7 9
    else:
        print(2 * (i - 5), end=" ") # even numbers: 2 4 6 8 10
    i += 1

Output:

1 3 5 7 9 2 4 6 8 10

Let us trace through the logic.

One loop. Both odd and even. Clean.

12. Factorial of a Given Number

Factorial of a number means multiply it with every number below it down to 1.

Factorial of 5 = 5 × 4 × 3 × 2 × 1 = 120

Written as 5!

Factorial of 0 = 1 (by definition)
Factorial of 1 = 1

Quick question for you.

What is 4!?

4 × 3 × 2 × 1 = 24.

n = int(input("Enter a number: "))

i = 1
result = 1

while i <= n:
    result = result * i
    i += 1

print("Factorial of", n, "is:", result)

Input: 5

Output:

Factorial of 5 is: 120

Input: 0

Output:

Factorial of 0 is: 1

When n = 0 — the while loop condition i <= 0 is false immediately. Loop never runs. result stays 1. Which is the correct answer.

Let us trace 5!:

result = 1
i=1 → result = 1 * 1 = 1
i=2 → result = 1 * 2 = 2
i=3 → result = 2 * 3 = 6
i=4 → result = 6 * 4 = 24
i=5 → result = 24 * 5 = 120

13. Sum of First N Numbers

Add all numbers from 1 to n.

Sum of first 5 = 1 + 2 + 3 + 4 + 5 = 15.

n = int(input("Enter n: "))

i = 1
total = 0

while i <= n:
    total += i
    i += 1

print("Sum of first", n, "numbers:", total)

Input: 5

Output:

Sum of first 5 numbers: 15

Input: 10

Output:

Sum of first 10 numbers: 55

total = 0 — starts at zero.
Each step adds i to total.
After the loop — total holds the sum.

Quick question for you.

There is actually a formula for this — n * (n + 1) / 2. For n = 10, that gives 10 * 11 / 2 = 55. Same answer.

So why use a loop?

Because loops are easier to understand and modify. What if you want the sum of only even numbers from 1 to n? The formula does not directly help. The loop does — just add if i % 2 == 0.

14. Print First 5 Prime Numbers

We already know how to check if a number is prime. Now we keep checking numbers one by one until we have found 5 primes.

count = 0
n = 2

while count < 5:
    i = 1
    divisors = 0

    while i <= n:
        if n % i == 0:
            divisors += 1
        i += 1

    if divisors == 2:
        print(n, end=" ")
        count += 1

    n += 1

print()

Output:

2 3 5 7 11

Let us understand the structure.

Outer loop — runs until we have found 5 primes. count < 5.

Inner loop — checks if current n is prime by counting divisors.

If n is prime — print it, increase count.

Move to next number — n += 1.

Two nested while loops. Outer controls how many primes we want. Inner checks if each number is prime.

Quick question for you.

Why do we start n at 2 and not 1?

Because 1 is not a prime number. It has only 1 divisor. Starting at 2 skips 1 naturally. 2 is the smallest prime number.

15. Sum of First 5 Prime Numbers

Same logic as program 14 — but instead of printing, we add each prime to a total.

count = 0
n = 2
total = 0

while count < 5:
    i = 1
    divisors = 0

    while i <= n:
        if n % i == 0:
            divisors += 1
        i += 1

    if divisors == 2:
        total += n
        count += 1

    n += 1

print("Sum of first 5 prime numbers:", total)

Output:

Sum of first 5 prime numbers: 28

First 5 primes are 2, 3, 5, 7, 11. Sum = 2+3+5+7+11 = 28.

The only change from program 14 — instead of print(n) we write total += n. And at the end we print the total.

Quick Summary — What Each Program Teaches

Program	What It Teaches
Count of Divisors	`%` operator, counting with a loop
Prime Number	Divisor count == 2 means prime
Perfect Number	Sum of proper divisors == number
Odd Then Even	Math formula inside loop to generate patterns
Factorial	Multiplying instead of adding in a loop
Sum of N Numbers	Running total using `total += i`
First 5 Primes	Nested loops — outer controls count, inner checks prime
Sum of First 5 Primes	Same as above — add instead of print

The key idea connecting all these programs.

Every problem becomes simple when you break it into steps.

Is this number prime? → Count its divisors. If 2, yes.
Is this number perfect? → Sum its proper divisors. If equal, yes.
What is the factorial? → Multiply while counting down.

The loop just repeats those steps automatically.

Try modifying the programs.

What are the first 10 prime numbers?
What is the factorial of 10?
Sum of first 20 numbers?
Is 496 a perfect number?

Change the numbers. Run the code. Verify your answers.

That hands-on practice is where loops truly click.

If you have a question — drop it in the comments below.

Thanks for reading. Keep building.

Inheritance in Java — Official Definition, Simple Explanation and Examples

DHANRAJ S — Fri, 05 Jun 2026 18:17:59 +0000

Hey!

Before we start — let me ask you something.

A child looks like their parent. Same eyes. Same nose. Same smile. They did not build those features from scratch — they inherited them.

But the child also has their own personality. Their own skills. Things the parent does not have.

That is exactly how inheritance works in Java.

One class gets everything from another class — and can also add its own things on top.

Let us understand it fully — starting with the official definition, then breaking it down simply.

1. Official Definition

From the Oracle Java Documentation:

"A class that is derived from another class is called a subclass (also a derived class, extended class, or child class). The class from which the subclass is derived is called a superclass (also a base class or parent class). A subclass inherits all the members (fields, methods, and nested classes) from its superclass."

From GeeksforGeeks:

"Inheritance in Java is a mechanism in which one class acquires the properties (fields) and behaviors (methods) of another class. It is an important part of OOPs (Object-Oriented Programming System)."

2. What Does That Mean?

Forget the formal words for a second.

Imagine you are building a game. You have a Vehicle class with basic properties — speed, fuel, color. Now you want a Car class and a Bike class. Both are vehicles. Both have speed, fuel, and color.

Without inheritance — you write speed, fuel, and color twice. Once in Car. Once in Bike. Same code. Repeated.

With inheritance — Car and Bike simply say "I am a Vehicle." They get all of Vehicle's code automatically. Then they add their own unique things on top.

One class. Written once. Used everywhere it is needed.

That is inheritance.

3. Why Do We Need Inheritance?

Three clear reasons.

No repeated code

Write a feature once in the parent class. Every child class gets it automatically. No copy-pasting.

Easy to maintain

Need to fix something? Fix it in the parent. All child classes get the fix. You do not touch 5 different files.

Logical structure

Real-world things have natural parent-child relationships. Animal → Dog. Vehicle → Car. Employee → Manager. Inheritance lets you model that in code.

4. The Syntax

class Parent {
    // parent code
}

class Child extends Parent {
    // child code
}

extends is the keyword. The child class extends the parent class.

That one word — extends — is all Java needs to set up inheritance.

5. A Simple Example

class Animal {
    String name;
    int age;

    void eat() {
        System.out.println(name + " is eating.");
    }

    void sleep() {
        System.out.println(name + " is sleeping.");
    }
}

class Dog extends Animal {
    void bark() {
        System.out.println(name + " is barking.");
    }
}

class Cat extends Animal {
    void meow() {
        System.out.println(name + " is meowing.");
    }
}

public class Main {
    public static void main(String[] args) {

        Dog d = new Dog();
        d.name = "Bruno";
        d.age = 3;
        d.eat();    // inherited from Animal
        d.sleep();  // inherited from Animal
        d.bark();   // Dog's own method

        Cat c = new Cat();
        c.name = "Mimi";
        c.age = 2;
        c.eat();    // inherited from Animal
        c.meow();   // Cat's own method
    }
}

Output:

Bruno is eating.
Bruno is sleeping.
Bruno is barking.
Mimi is eating.
Mimi is meowing.

Dog and Cat never defined eat() or sleep(). But they use them. Because they inherited them from Animal.

Quick question for you.

If you add a new method breathe() in the Animal class — which classes automatically get it?

Both Dog and Cat. Every class that extends Animal gets breathe() without you changing anything in those classes.

That is the power of inheritance.

6. Types of Inheritance in Java

Java supports four types of inheritance.

Single Inheritance

One child. One parent.

Animal
  ↓
Dog

class Animal { }
class Dog extends Animal { }

Multilevel Inheritance

Child becomes a parent for the next level.

Animal
  ↓
Dog
  ↓
Puppy

class Animal {
    void eat() {
        System.out.println("Eating...");
    }
}

class Dog extends Animal {
    void bark() {
        System.out.println("Barking...");
    }
}

class Puppy extends Dog {
    void weep() {
        System.out.println("Weeping...");
    }
}

Puppy p = new Puppy();
p.eat();   // from Animal
p.bark();  // from Dog
p.weep();  // Puppy's own

Output:

Eating...
Barking...
Weeping...

Puppy inherits from Dog. Dog inherits from Animal. So Puppy gets everything from both.

Hierarchical Inheritance

One parent. Many children.

    Animal
   ↙      ↘
Dog        Cat

class Animal {
    void breathe() {
        System.out.println("Breathing...");
    }
}

class Dog extends Animal {
    void bark() {
        System.out.println("Barking...");
    }
}

class Cat extends Animal {
    void meow() {
        System.out.println("Meowing...");
    }
}

Both Dog and Cat inherit from the same Animal. Common code lives in one place.

Multiple Inheritance — Not Supported Directly

Quick question for you.

Can a class extend two parent classes in Java?

class A { }
class B { }
class C extends A, B { }  // Error in Java

No. Java does not allow this with classes. It causes something called the Diamond Problem — where Java gets confused about which parent's version to use when both have the same method.

Java solves this using Interfaces — which we will cover in a separate blog.

7. The super Keyword

super is used to access the parent class's members from inside the child class.

Calling parent method

class Animal {
    void sound() {
        System.out.println("Some sound...");
    }
}

class Dog extends Animal {
    void sound() {
        super.sound();  // calls Animal's sound()
        System.out.println("Dog barks!");
    }
}

Dog d = new Dog();
d.sound();

Output:

Some sound...
Dog barks!

super.sound() runs the parent version first. Then the child adds its own.

Calling parent constructor

class Animal {
    String name;

    Animal(String name) {
        this.name = name;
        System.out.println("Animal created: " + name);
    }
}

class Dog extends Animal {
    String breed;

    Dog(String name, String breed) {
        super(name);  // calls Animal's constructor
        this.breed = breed;
        System.out.println("Dog created. Breed: " + breed);
    }
}

Dog d = new Dog("Bruno", "Labrador");

Output:

Animal created: Bruno
Dog created. Breed: Labrador

super(name) must be the first line in the child constructor. It passes the value up to the parent constructor.

8. Method Overriding

When the child class writes its own version of a method that already exists in the parent — that is method overriding.

class Animal {
    void sound() {
        System.out.println("Some animal sound");
    }
}

class Dog extends Animal {
    @Override
    void sound() {
        System.out.println("Dog barks");
    }
}

class Cat extends Animal {
    @Override
    void sound() {
        System.out.println("Cat meows");
    }
}

Animal a = new Animal();
Dog d = new Dog();
Cat c = new Cat();

a.sound();  // Some animal sound
d.sound();  // Dog barks
c.sound();  // Cat meows

@Override — tells Java "this method is replacing the parent's version." Java checks that the method actually exists in the parent. If you made a spelling mistake — Java catches it.

Child uses its own version. Parent version is hidden.

This is called Runtime Polymorphism — because which version to call is decided when the program runs, not at compile time.

9. What Is Inherited and What Is Not?

Quick question for you.

Does a child class inherit everything from the parent?

Not everything. Here is what gets inherited and what does not.

	Inherited?
Public methods	Yes
Protected methods	Yes
Public fields	Yes
Protected fields	Yes
Private fields	No
Private methods	No
Constructors	No
Static members	Yes — but not overridden

Private members stay private. The child cannot access them directly. But if the parent has a public getter method — the child can use that to access them.

Constructors are not inherited. But you can call them using super().

10. A Real Example — Employee System

class Employee {
    String name;
    int id;
    double basicSalary;

    Employee(String name, int id, double basicSalary) {
        this.name = name;
        this.id = id;
        this.basicSalary = basicSalary;
    }

    void displayDetails() {
        System.out.println("Name: " + name);
        System.out.println("ID: " + id);
        System.out.println("Basic Salary: " + basicSalary);
    }
}

class Manager extends Employee {
    double bonus;

    Manager(String name, int id, double basicSalary, double bonus) {
        super(name, id, basicSalary);
        this.bonus = bonus;
    }

    @Override
    void displayDetails() {
        super.displayDetails();
        System.out.println("Bonus: " + bonus);
        System.out.println("Total Salary: " + (basicSalary + bonus));
    }
}

class Intern extends Employee {
    int durationMonths;

    Intern(String name, int id, double basicSalary, int durationMonths) {
        super(name, id, basicSalary);
        this.durationMonths = durationMonths;
    }

    @Override
    void displayDetails() {
        super.displayDetails();
        System.out.println("Internship Duration: " + durationMonths + " months");
    }
}

public class Main {
    public static void main(String[] args) {

        Manager m = new Manager("Ravi", 101, 75000, 20000);
        Intern i = new Intern("Anu", 201, 15000, 6);

        System.out.println("--- Manager ---");
        m.displayDetails();

        System.out.println("\n--- Intern ---");
        i.displayDetails();
    }
}

Output:

--- Manager ---
Name: Ravi
ID: 101
Basic Salary: 75000.0
Bonus: 20000.0
Total Salary: 95000.0

--- Intern ---
Name: Anu
ID: 201
Basic Salary: 15000.0
Internship Duration: 6 months

Employee has the common code — name, id, salary, displayDetails. Manager and Intern extend it. They add their own fields. They override displayDetails to show their extra info. They do not repeat name, id, or salary anywhere.

Quick Summary — 5 Things to Remember

Inheritance — child class gets all public and protected members of the parent class automatically using extends.
Types — Single, Multilevel, Hierarchical are supported. Multiple inheritance with classes is not allowed in Java.
super — used to access parent class methods and constructors from the child class.
Method Overriding — child writes its own version of a parent method. Use @Override to tell Java clearly.
What is not inherited — private members and constructors. Everything else public or protected is inherited.

Inheritance is the backbone of Object Oriented Programming. Once you get it — classes start to feel organized and logical instead of random.

Try building the Employee system above. Add a new class called Developer that extends Employee. Give it a techStack field. Override displayDetails to show it.

If you have a question — drop it in the comments below.

References

Thanks for reading. Keep building.

Python While Loop Programs — Patterns and Numbers Explained Simply

DHANRAJ S — Thu, 04 Jun 2026 14:24:49 +0000

Hey!

Let me ask you something first.

Can you count from 1 to 5? Of course you can.

Can you tell me all multiples of 3 between 1 and 30? Probably yes, but it takes time.

Can you find all divisors of 48? Now that takes a bit of thinking.

Python can do all three in seconds. With a while loop.

Today we are going to solve 8 programs using only while loops. Each one builds on the last. By the end — you will be very comfortable with while loops and number logic.

Let us start.

Before We Begin — How a While Loop Works

i = 1

while i <= 5:
    print(i)
    i += 1

Output:

i = 1 — starting point.
while i <= 5 — keep running as long as i is 5 or less.
i += 1 — increase i by 1 every step. Without this — infinite loop.

Every program below follows this same structure. Start somewhere. Run until a condition. Move forward each step.

1. Print 1 1 1 1 1

Print the number 1 five times.

Quick question for you.

What do you think changes in the loop if you want to print the same number every time instead of increasing?

Nothing changes in the loop — only the print statement. You just print a fixed value instead of i.

i = 1

while i <= 5:
    print(1, end=" ")
    i += 1

Output:

1 1 1 1 1

end=" " — prints everything on the same line with a space between. Without it — each number prints on a new line.

i is still counting the steps. But we print 1 every time instead of i.

2. Print 1 2 3 4 5

Print numbers from 1 to 5 in order.

i = 1

while i <= 5:
    print(i, end=" ")
    i += 1

Output:

1 2 3 4 5

This time we print i directly. i starts at 1 and goes up by 1 each step.

Simple. But this is the base pattern for everything else.

3. Print 1 3 5 7 9 — Odd Numbers

Print the first five odd numbers.

Quick question for you.

What is the pattern here? How much does each number increase by?

Each number increases by 2. 1 → 3 → 5 → 7 → 9.

So instead of i += 1 — we use i += 2.

i = 1

while i <= 9:
    print(i, end=" ")
    i += 2

Output:

1 3 5 7 9

Start at 1. Jump by 2 each time. Stop at 9.

The jump size is what creates the pattern.

4. Print 3 6 9 12 15 — Multiples of 3

Print the first five multiples of 3.

Same idea — just start at 3 and jump by 3 each time.

i = 3

while i <= 15:
    print(i, end=" ")
    i += 3

Output:

3 6 9 12 15

Start at 3. Add 3 every step. Stop at 15.

4.1 Print 15 12 9 6 3 — Reverse

Now print the same series backwards.

Quick question for you.

If going forward means i += 3 — what do you think going backward means?

i -= 3. We start at the biggest number and subtract each time.

i = 15

while i >= 3:
    print(i, end=" ")
    i -= 3

Output:

15 12 9 6 3

Start at 15. Subtract 3 each step. Stop when i goes below 3.

4.2 Print 10 8 6 4 2 — Reverse Even Numbers

Start at 10. Go down. Jump by 2.

i = 10

while i >= 2:
    print(i, end=" ")
    i -= 2

Output:

10 8 6 4 2

Start at 10. Subtract 2 each step. Stop when i goes below 2.

4.3 Print 9 7 5 3 1 — Reverse Odd Numbers

Start at 9. Go down. Jump by 2.

i = 9

while i >= 1:
    print(i, end=" ")
    i -= 2

Output:

9 7 5 3 1

Start at 9. Subtract 2 each step. Stop when i goes below 1.

Quick Recap — The Pattern So Far

Before we move to harder programs — let us notice what we learned.

Going forward — start small, use +=, condition checks upper limit.
Going backward — start big, use -=, condition checks lower limit.
Jump size — controls the gap between numbers. += 1 gives every number. += 2 gives every other number. += 3 gives multiples of 3.

That is all that changes between the programs above. Same loop structure. Different start, step, and direction.

5. Multiples of 3 AND 5

Print numbers from 1 to 50 that are divisible by both 3 and 5.

A number divisible by both 3 and 5 is divisible by 15. Like 15, 30, 45.

Quick question for you.

How do you check if a number is divisible by 3 and 5 at the same time?

Use % — the modulo operator. It gives the remainder.

15 % 3 = 0 — 15 is divisible by 3.
15 % 5 = 0 — 15 is divisible by 5.

If both remainders are 0 — divisible by both.

i = 1

while i <= 50:
    if i % 3 == 0 and i % 5 == 0:
        print(i, end=" ")
    i += 1

Output:

15 30 45

The loop checks every number from 1 to 50. Only when both conditions are true — it prints.

6. Multiples of 3 OR 5

Print numbers from 1 to 20 that are divisible by 3 or 5 — or both.

The only change — and becomes or.

i = 1

while i <= 20:
    if i % 3 == 0 or i % 5 == 0:
        print(i, end=" ")
    i += 1

Output:

3 5 6 9 10 12 15 18 20

Quick question for you.

Why does 15 appear in this list too?

Because 15 is divisible by both 3 and 5. or means — if at least one condition is true. 15 satisfies both, so it definitely satisfies or.

Notice the difference from program 5. Program 5 gave only 15, 30, 45. Program 6 gives many more numbers because the condition is less strict.

7. Divisors of a Given Number

A divisor is a number that divides another number exactly — with no remainder.

Divisors of 12 are: 1, 2, 3, 4, 6, 12.

How do we find them? Check every number from 1 to the given number. If it divides evenly — it is a divisor.

n = int(input("Enter a number: "))

i = 1

while i <= n:
    if n % i == 0:
        print(i, end=" ")
    i += 1

Input: 12

Output:

1 2 3 4 6 12

n % i == 0 — if dividing n by i gives remainder 0, then i is a divisor of n.

The loop checks every number from 1 to n. Any that divides evenly gets printed.

Quick question for you.

What are the divisors of 7?

Try it mentally. Which numbers divide 7 exactly?

Only 1 and 7. Because 7 is a prime number. It has only two divisors — 1 and itself.

Run the program with input 7 and confirm.

8. Count of Divisors of a Given Number

Same as program 7 — but instead of printing divisors, we just count them.

n = int(input("Enter a number: "))

i = 1
count = 0

while i <= n:
    if n % i == 0:
        count += 1
    i += 1

print("Number of divisors:", count)

Input: 12

Output:

Number of divisors: 6

count = 0 — start with 0.
Every time we find a divisor — count += 1.
At the end — print the total count.

Input: 7

Output:

Number of divisors: 2

7 has 2 divisors — 1 and 7.

Quick question for you.

Which number between 1 and 20 do you think has the most divisors?

Try to guess. Then run the program for each number from 1 to 20 and check. The answer might surprise you.

It is 12. It has 6 divisors — 1, 2, 3, 4, 6, 12.

Quick Summary — What These 8 Programs Teach

Same number — print a fixed value, not i.
Sequence — print i directly as it increases.
Odd numbers — start at 1, jump by 2.
Multiples — start at the number, jump by that number.
Reverse — start big, subtract instead of add.
AND condition — both must be true. Stricter. Fewer results.
OR condition — at least one must be true. Looser. More results.
Divisors — check every number from 1 to n using %. Count or print matches.

All 8 programs use the same simple while loop structure. What changes is the starting point, the jump size, the direction, and the condition inside.

Once you understand those four things — you can build any number pattern.

Try modifying the programs. What if you want multiples of 4 from 1 to 40? What if you want divisors of 100? What if you want to print in reverse from 20 to 1 jumping by 3?

Make the changes. Run the code. See it work.

That is when while loops really click.

If you have a question — drop it in the comments below.

Thanks for reading. Keep building.

Constructors in Java — What, Why, When and How to Use Them

DHANRAJ S — Wed, 03 Jun 2026 06:31:50 +0000

Hey!

You are buying a new phone. It comes out of the box already set up — language, time zone, default wallpaper.

You did not set those things. The phone came ready from the factory.

That is exactly what a constructor does in Java.

When you create an object — the constructor runs automatically and sets it up with starting values. You never call it. It just runs the moment the object is created.

1. What Is a Constructor?

A constructor is a special block of code that runs automatically when an object is created.

Its job — initialize the object. Give it starting values.

public class Student {
    String name;
    int age;

    Student(String name, int age) {
        this.name = name;
        this.age = age;
    }
}

Create the object:

Student s1 = new Student("Ravi", 20);

The constructor runs immediately. name becomes "Ravi". age becomes 20. Object is ready.

2. Three Rules of a Constructor

A constructor looks like a method — but it follows three strict rules.

Same name as the class

public class Student {
    Student() { }   // correct — same name as class
}

No return type — not even void

void Student() { }   // NOT a constructor — has void
Student() { }        // constructor — no return type

Java calls it automatically — you never call it manually

The moment you write new Student() — Java runs the constructor. You do not call it yourself.

Quick question for you.

What happens if you accidentally add void before the constructor name?

Java treats it as a regular method. The object still gets created — but that method never runs automatically. It just becomes an ordinary method sitting there doing nothing at object creation time.

3. Why Do We Need Constructors?

Without a constructor — you set values one by one after creating the object.

Student s1 = new Student();
s1.name = "Ravi";
s1.age = 20;
s1.course = "Computer Science";

Three extra lines for one object. Miss one — incomplete data.

With a constructor:

Student s1 = new Student("Ravi", 20, "Computer Science");

One line. Fully set up. Safe.

4. Types of Constructors

Java has three types.

Default Constructor — Java provides it automatically when you write no constructor.

public class Student {
    String name;
    int age;
    // Java silently adds: Student() { }
}

Student s1 = new Student();
System.out.println(s1.name);  // null
System.out.println(s1.age);   // 0

Object is created but values are just Java defaults — null and 0.

Quick question for you.

What happens to the default constructor the moment you write your own constructor?

Java removes it. It only provides the default when you have written nothing. Write even one constructor yourself — the default is gone. If you still want a no-argument constructor, you must write it yourself.

No-Argument Constructor — you write it yourself with no parameters but your own logic inside.

Student() {
    name = "Unknown";
    age = 0;
    course = "Not Assigned";
}

Now the object starts with meaningful values — not just null and 0.

Parameterized Constructor — most commonly used. You pass values at the time of creation.

public class Student {
    String name;
    int age;
    String course;

    Student(String name, int age, String course) {
        this.name = name;
        this.age = age;
        this.course = course;
    }

    void display() {
        System.out.println(name + " | " + age + " | " + course);
    }
}

Student s1 = new Student("Ravi", 20, "Computer Science");
Student s2 = new Student("Anu", 22, "Electronics");

s1.display();  // Ravi | 20 | Computer Science
s2.display();  // Anu | 22 | Electronics

Each object gets its own values. Clean. One line per object.

5. What Is this Keyword?

Inside a parameterized constructor — the parameter name and the instance variable often have the same name.

Student(String name, int age) {
    this.name = name;
    this.age = age;
}

this.name — the instance variable of this object.
name — the parameter coming in.

Without this:

Student(String name, int age) {
    name = name;  // parameter assigns to itself — instance variable untouched
    age = age;
}

The instance variable never gets the value.

Quick question for you.

What does s1.name print if you forget this and write name = name?

null. The instance variable was never set. The parameter just talked to itself and disappeared.

6. Constructor Overloading

Just like methods — you can have multiple constructors in the same class with different parameters.

public class Student {
    String name;
    int age;
    String course;

    Student() {
        this.name = "Unknown";
        this.age = 0;
        this.course = "Not Assigned";
    }

    Student(String name) {
        this.name = name;
        this.age = 0;
        this.course = "Not Assigned";
    }

    Student(String name, int age, String course) {
        this.name = name;
        this.age = age;
        this.course = course;
    }

    void display() {
        System.out.println(name + " | " + age + " | " + course);
    }
}

Student s1 = new Student();
Student s2 = new Student("Ravi");
Student s3 = new Student("Anu", 22, "Electronics");

s1.display();  // Unknown | 0 | Not Assigned
s2.display();  // Ravi | 0 | Not Assigned
s3.display();  // Anu | 22 | Electronics

You choose how much to pass. Java picks the right constructor automatically at compile time.

7. Constructor vs Method

	Constructor	Method
Name	Same as class	Any name
Return type	None — not even void	Must have one
Called by	Java automatically	You manually
Purpose	Initialize the object	Perform an action
Overloading	Yes	Yes
Inherited	No	Yes

Quick Summary — 5 Things to Remember

Constructor runs automatically when an object is created. You never call it manually.
Three rules — same name as class, no return type, called automatically by Java.
Three types — default (Java provides), no-argument (you write with your logic), parameterized (you pass values).
this keyword — refers to the current object's instance variable. Without it — the parameter assigns to itself and instance variable gets nothing.
Constructor overloading — multiple constructors, different parameters. Java picks the right one at compile time.

Constructors are the first thing that runs when an object is born. Understanding them properly means you understand how objects start their life in Java.

Try the Student class above. Add a constructor that takes only name and course — and sets a default age of 18. Create an object with it and call display().

If you have a question — drop it in the comments below.

References

Thanks for reading. Keep building.

Java Methods and Method Overloading — Explained Simply

DHANRAJ S — Tue, 02 Jun 2026 14:27:07 +0000

Hey!

Let me ask you something before we start.

You go to a coffee shop. You order a coffee. The barista asks — small, medium, or large? With milk or without? Hot or cold?

Same order — "one coffee." But the result is different based on what details you give.

That is method overloading in Java.

Same method name. Different inputs. Different results.

By the end of this blog — you will understand methods, method overloading, and why Java developers call it compile time polymorphism.

Let us start.

1. What Is a Method?

A method is a block of code that does a specific job. You write it once and call it whenever you need it.

Think of it like a washing machine. You press the button — it washes. You do not care how it works inside. You just press and get the result.

public static void greet() {
    System.out.println("Hello! Welcome.");
}

You write this once. Every time you need to greet — you just call greet(). No need to write the same print statement again and again.

2. Structure of a Method

public static int add(int a, int b) {
    return a + b;
}

Let us read this piece by piece.

public — this method is accessible from anywhere.

static — you can call this method without creating an object.

int — the return type. This method gives back an integer value.

add — the method name.

(int a, int b) — parameters. The inputs this method needs to do its job.

return a + b — the result sent back to whoever called the method.

3. Calling a Method

public class Calculator {

    public static int add(int a, int b) {
        return a + b;
    }

    public static void main(String[] args) {
        int result = add(10, 20);
        System.out.println("Sum: " + result);  // Sum: 30
    }
}

add(10, 20) — calling the method with values 10 and 20.

The method runs, adds them, and returns 30. That 30 is stored in result.

4. Types of Methods

There are four simple variations.

No parameter, no return

public static void sayHello() {
    System.out.println("Hello!");
}

Takes nothing. Returns nothing. Just runs and does its job.

With parameters, no return

public static void greet(String name) {
    System.out.println("Hello, " + name);
}

Takes a name. Prints it. Returns nothing — so return type is void.

No parameter, with return

public static String getAppName() {
    return "MyApp";
}

Takes nothing. Returns a String value.

With parameters, with return

public static int multiply(int a, int b) {
    return a * b;
}

Takes two numbers. Returns their product.

Quick question for you.

If a method has void as the return type — what does that mean?

It means the method does not return anything. It just performs an action — printing, saving, updating — and finishes. No value comes back.

5. Why Do We Need Methods at All?

Without methods — you repeat the same code everywhere.

// Without methods — repeated code
System.out.println("Area: " + (5 * 3));
System.out.println("Area: " + (8 * 4));
System.out.println("Area: " + (6 * 7));

With a method — write once, use anywhere.

public static int area(int length, int width) {
    return length * width;
}

System.out.println("Area: " + area(5, 3));  // 15
System.out.println("Area: " + area(8, 4));  // 32
System.out.println("Area: " + area(6, 7));  // 42

Clean. Reusable. If the logic changes — you update one place. Not three.

6. Now — What Is Method Overloading?

Here is a situation.

You are building a calculator. You need to add numbers.

Sometimes the user passes two integers.
Sometimes they pass three integers.
Sometimes they pass decimal numbers.

Without overloading — you would name them differently.

public static int addTwoInts(int a, int b) { ... }
public static int addThreeInts(int a, int b, int c) { ... }
public static double addTwoDoubles(double a, double b) { ... }

That is messy. Three different names for something that is essentially the same action — adding numbers.

Method overloading lets you use the same name for all of them.

public static int add(int a, int b) { ... }
public static int add(int a, int b, int c) { ... }
public static double add(double a, double b) { ... }

Same name add. Different parameters. Java figures out which one to call based on what you pass.

That is method overloading.

7. How Does Overloading Work? — The Rules

For overloading to work — the methods must differ in at least one of these ways.

Number of parameters

public static int add(int a, int b) { ... }         // 2 params
public static int add(int a, int b, int c) { ... }  // 3 params

Type of parameters

public static int add(int a, int b) { ... }         // int params
public static double add(double a, double b) { ... } // double params

Order of parameters

public static void display(int a, String b) { ... }
public static void display(String a, int b) { ... }

Quick question for you.

Can you overload a method by just changing the return type?

public static int getValue() { return 1; }
public static double getValue() { return 1.0; }

No. This is not valid overloading. Java does not allow this. The return type alone is not enough to distinguish two methods. Java needs to know which one to call at the point you call it — and at that point, it only sees the method name and arguments, not the return type.

8. A Full Overloading Example

public class Calculator {

    // Two integers
    public static int add(int a, int b) {
        System.out.println("Adding two integers");
        return a + b;
    }

    // Three integers
    public static int add(int a, int b, int c) {
        System.out.println("Adding three integers");
        return a + b + c;
    }

    // Two doubles
    public static double add(double a, double b) {
        System.out.println("Adding two doubles");
        return a + b;
    }

    // int and double
    public static double add(int a, double b) {
        System.out.println("Adding int and double");
        return a + b;
    }

    public static void main(String[] args) {
        System.out.println(add(10, 20));           // calls first method
        System.out.println(add(10, 20, 30));        // calls second method
        System.out.println(add(1.5, 2.5));          // calls third method
        System.out.println(add(5, 3.14));           // calls fourth method
    }
}

Output:

Adding two integers
30
Adding three integers
60
Adding two doubles
4.0
Adding int and double
8.14

Same name add. Four different versions. Java picks the right one based on the arguments you pass. You do not have to think about which version to call — you just call add() and Java handles it.

9. Why Is Method Overloading Called Compile Time Polymorphism?

This is the question most beginners skip. But it is important to understand.

Let us break it word by word.

Polymorphism means — one name, many forms. The word comes from Greek — poly means many, morph means form.

add is one name. But it has four forms. Each form behaves differently based on the input.

That is polymorphism.

Compile time means — the decision of which form to use is made at compile time. Not when the program runs.

When you write add(10, 20) — the Java compiler looks at your arguments right there and says — "two integers. I know exactly which add method to call. I will lock that in now."

The decision is made before the program even runs.

You write: add(10, 20)
            ↓
Compiler checks: two int arguments
            ↓
Compiler says: call add(int a, int b)
            ↓
Decision is locked at compile time
            ↓
Program runs — already knows which method to use

This is why it is called compile time polymorphism. Also called static polymorphism or early binding — because the binding between the method call and the method definition happens early, at compile time.

Quick question for you.

If the decision is already made at compile time — does that make the program faster at runtime?

Yes. Because at runtime — Java does not need to figure out which method to call. That work is already done. The program just executes the pre-decided method directly.

10. Real World Example — print() Method

You have been using method overloading without realizing it.

System.out.println() is an overloaded method.

System.out.println(42);           // int version
System.out.println(3.14);         // double version
System.out.println("Hello");      // String version
System.out.println(true);         // boolean version
System.out.println('A');          // char version

Five different types. Same method name. Java picks the right version based on what you pass.

You never had to write printInt() or printString() or printDouble(). Just println. That is the clean power of method overloading.

11. Method Overloading vs Method Overriding

Beginners often confuse these two. They sound similar but are completely different.

	Method Overloading	Method Overriding
Where	Same class	Parent and child class
Method name	Same	Same
Parameters	Must be different	Must be same
Decided at	Compile time	Runtime
Also called	Compile time polymorphism	Runtime polymorphism
Purpose	Same action, different inputs	Change inherited behaviour

Overloading — same class, different inputs, decided at compile time.

Overriding — different classes (parent/child), same inputs, decided at runtime.

We will cover overriding in a separate blog. For now — just know they are not the same thing.

12. Common Mistakes to Avoid

Trying to overload with only return type

public static int getValue() { return 1; }
public static double getValue() { return 1.0; }  // Error

Not valid. Return type alone cannot differentiate overloaded methods.

Confusing overloading with overriding

Overloading is in the same class. Overriding involves inheritance. Do not mix them up.

Too many overloaded versions

public static int add(int a) { ... }
public static int add(int a, int b) { ... }
public static int add(int a, int b, int c) { ... }
public static int add(int a, int b, int c, int d) { ... }

For too many parameters — consider using an array or a list instead. Overloading is useful but do not overdo it.

Quick Summary — 5 Things to Remember

A method is reusable code — write once, call whenever needed. Keeps your code clean and DRY (Do not Repeat Yourself).
Method overloading — same method name, different parameters. Java picks the right version at compile time based on the arguments.
Overloading rules — methods must differ in number of parameters, type of parameters, or order of parameters. Return type alone is not enough.
Compile time polymorphism — one name, many forms, decision made at compile time. Also called static binding or early binding.
You already use overloading — System.out.println() is a real-world example. Same name. Works with int, double, String, boolean, char.

Methods make your code organised. Method overloading makes it clean and natural to use.

Instead of remembering five different method names for the same kind of action — you just remember one. Java does the rest.

Try writing the Calculator class from section 8. Add one more overloaded version — maybe one that takes three doubles. Call it and see Java pick it correctly.

Then try the mistake on purpose — change only the return type and see the error Java gives you.

That hands-on experience will make everything click.

If you have a question — drop it in the comments below.

Thanks for reading. Keep building.

Java Variables Explained — Simply and in Detail

DHANRAJ S — Mon, 01 Jun 2026 11:59:15 +0000

Hey!

Let me start with a simple question.

When you go to the grocery store — you pick up items and put them in a basket. The basket holds everything until you reach the billing counter.

Now imagine your program needs to remember something. A user's name. A price. A score. A status.

Where does it hold that information while the program is running?

In a variable.

A variable is your program's basket. It picks up a value and holds it until you need it.

Let us understand everything about variables in Java — from the basics to the details most beginners miss.

1. What Is a Variable?

A variable is a container that stores a value in memory.

Every variable has three things.

A type — what kind of data it holds
A name — how you refer to it
A value — what is actually stored in it

int age = 25;

int — the type. This variable holds a whole number.
age — the name. This is how you use it in your code.
25 — the value. What is stored inside.

Simple. But there is a lot more to understand about how variables work in Java.

2. How to Declare a Variable

Declaring a variable means telling Java — "I need a container of this type with this name."

int age;

That is a declaration. You told Java to create a container called age that holds integers. But you have not put anything in it yet.

Initializing means giving it a value.

age = 25;

You can also declare and initialize in one line.

int age = 25;

Most of the time — you do both in one line. Cleaner and easier to read.

3. Rules for Naming Variables

Quick question for you.

Can you name a variable 1score? Or my score? Or class?

Let us go through the rules.

Must start with a letter, underscore, or dollar sign

int age = 25;       // valid
int _count = 10;    // valid
int $price = 99;    // valid
int 1score = 5;     // invalid — cannot start with a number

Cannot have spaces

int myScore = 100;   // valid
int my score = 100;  // invalid — space is not allowed

Cannot use Java reserved words

Some words are reserved by Java — int, class, while, if, for, return and more. You cannot use them as variable names.

int class = 5;    // invalid — class is a reserved word
int myClass = 5;  // valid

Case sensitive

int age = 25;
int Age = 30;
int AGE = 35;

These are three completely different variables. Java sees age, Age, and AGE as different names.

4. Naming Conventions — How Java Developers Write Variable Names

Rules are what Java enforces. Conventions are what developers follow to keep code clean and readable.

Java follows camelCase for variable names.

Start with a lowercase letter. Every new word starts with an uppercase.

int totalPrice = 500;
String firstName = "Ravi";
boolean isLoggedIn = true;
double bankBalance = 15000.75;

Not like this:

int TotalPrice = 500;      // looks like a class name
int total_price = 500;     // works but not Java convention
int totalprice = 500;      // hard to read

camelCase makes your code easier to read. And it matches what every Java developer expects to see.

5. Types of Variables in Java

This is the part most tutorials rush through. But it is very important.

In Java — there are three types of variables based on where they are declared.

Local Variables
Instance Variables
Static Variables

Let us understand each one clearly.

6. Local Variables

A local variable is declared inside a method. It only exists inside that method. Once the method is done — the variable is gone.

public class Example {
    public static void main(String[] args) {
        int score = 95;  // local variable
        System.out.println("Score: " + score);
    }
}

score is a local variable. It lives only inside main. You cannot access it anywhere else.

One important rule — local variables must be initialized before use.

public class Example {
    public static void main(String[] args) {
        int score;
        System.out.println(score);  // Error — score is not initialized
    }
}

Java will give you a compile error. Unlike instance variables — local variables do not get a default value. You must give them a value before using them.

Quick question for you.

What do you think happens if you try to use a local variable outside the method it was declared in?

public class Example {
    public static void main(String[] args) {
        int score = 95;
    }

    public static void show() {
        System.out.println(score);  // Error — score not visible here
    }
}

Compile error. score does not exist outside main. Local variables are strictly limited to the block they are declared in.

7. Instance Variables

An instance variable is declared inside a class — but outside any method. Every object created from that class gets its own copy.

public class Student {
    String name;      // instance variable
    int age;          // instance variable
    double marks;     // instance variable

    public static void main(String[] args) {
        Student s1 = new Student();
        s1.name = "Ravi";
        s1.age = 20;
        s1.marks = 89.5;

        Student s2 = new Student();
        s2.name = "Anu";
        s2.age = 22;
        s2.marks = 94.0;

        System.out.println(s1.name + " - " + s1.marks);  // Ravi - 89.5
        System.out.println(s2.name + " - " + s2.marks);  // Anu - 94.0
    }
}

s1 and s2 are two different objects. Each has their own name, age, and marks. Changing s1.name does not affect s2.name.

Instance variables get default values if you do not initialize them.

Type	Default Value
`int`	0
`double`	0.0
`boolean`	false
`char`	'\u0000' (empty)
`String` / Object	null

Quick question for you.

What will this print?

public class Example {
    int count;

    public static void main(String[] args) {
        Example e = new Example();
        System.out.println(e.count);
    }
}

It prints 0. Because count is an instance variable. It was not initialized. So Java gave it the default value for int which is 0.

8. Static Variables

A static variable is declared with the static keyword inside a class. There is only one copy of it — shared across all objects.

public class Student {
    static String schoolName = "ABC School";  // static variable
    String name;                              // instance variable

    public static void main(String[] args) {
        Student s1 = new Student();
        s1.name = "Ravi";

        Student s2 = new Student();
        s2.name = "Anu";

        System.out.println(s1.name + " studies at " + Student.schoolName);
        System.out.println(s2.name + " studies at " + Student.schoolName);
    }
}

Output:

Ravi studies at ABC School
Anu studies at ABC School

schoolName is the same for every student. It belongs to the class — not to any individual object. That is what static means.

If you change Student.schoolName = "XYZ School" — it changes for every object at once. Because there is only one copy.

9. The final Keyword — Constants

Sometimes you want a variable whose value never changes. A constant.

Use the final keyword.

final double PI = 3.14159265;
final int MAX_SCORE = 100;
final String APP_NAME = "MyApp";

Once assigned — you cannot change it.

final int MAX_SCORE = 100;
MAX_SCORE = 200;  // Error — cannot reassign a final variable

Java convention for constants — write them in ALL_CAPS with underscores between words.

MAX_SCORE. PI. APP_NAME. MAX_RETRY_COUNT.

Every developer who reads your code will immediately know — this value never changes.

10. var — Type Inference (Java 10+)

From Java 10 onwards — you can use var instead of writing the type. Java figures out the type from the value you assign.

var age = 25;           // Java knows this is int
var name = "Ravi";      // Java knows this is String
var price = 99.99;      // Java knows this is double
var isActive = true;    // Java knows this is boolean

This is called type inference. Java looks at the value on the right and decides the type.

But var only works for local variables. Not for instance variables or method parameters.

public class Example {
    var name = "Ravi";  // Error — var not allowed here

    public static void main(String[] args) {
        var score = 95;  // works fine here
    }
}

Quick question for you.

Can you use var without assigning a value immediately?

var score;        // Error
var score = 95;   // Correct

No. Because Java needs to see the value to figure out the type. Without a value — var does not know what type to use.

11. Scope of a Variable

Scope means — where in your code is this variable accessible?

Block scope

A variable declared inside {} only exists inside those curly braces.

public class Example {
    public static void main(String[] args) {
        int x = 10;

        if (x > 5) {
            int y = 20;  // y only exists inside this if block
            System.out.println(y);  // works fine
        }

        System.out.println(y);  // Error — y does not exist here
    }
}

y was declared inside the if block. Once the if block ends — y is gone.

Method scope

A local variable exists only within the method it was declared in.

Class scope

Instance and static variables exist as long as the object or class exists.

12. Putting It All Together — One Full Example

public class BankAccount {

    static String bankName = "Java Bank";   // static — same for all accounts
    String accountHolder;                    // instance — different per account
    double balance;                          // instance — different per account
    final double MIN_BALANCE = 500.0;        // constant — never changes

    public void deposit(double amount) {
        double newBalance = balance + amount;  // local — only inside this method
        balance = newBalance;
        System.out.println("Deposited: " + amount + " | Balance: " + balance);
    }

    public void withdraw(double amount) {
        double remaining = balance - amount;   // local — only inside this method
        if (remaining >= MIN_BALANCE) {
            balance = remaining;
            System.out.println("Withdrawn: " + amount + " | Balance: " + balance);
        } else {
            System.out.println("Cannot withdraw. Minimum balance must be " + MIN_BALANCE);
        }
    }

    public static void main(String[] args) {
        BankAccount acc1 = new BankAccount();
        acc1.accountHolder = "Ravi";
        acc1.balance = 5000.0;

        System.out.println("Bank: " + BankAccount.bankName);
        System.out.println("Account holder: " + acc1.accountHolder);

        acc1.deposit(1000);
        acc1.withdraw(3000);
        acc1.withdraw(2000);
    }
}

Output:

Bank: Java Bank
Account holder: Ravi
Deposited: 1000.0 | Balance: 6000.0
Withdrawn: 3000.0 | Balance: 3000.0
Cannot withdraw. Minimum balance must be 500.0

This one example uses all four types — static, instance, local, and final — in a real context.

Read through it. Trace each variable. Notice where each one lives and how long it exists.

Quick Summary — 6 Things to Remember

A variable needs a type, a name, and a value — declare it, initialize it, use it.
Local variables — live inside a method. Must be initialized before use. Disappear when the method ends.
Instance variables — live inside a class. Each object gets its own copy. Get default values automatically.
Static variables — shared across all objects. One copy for the whole class. Access with the class name.
final variables — constants. Value never changes. Write them in ALL_CAPS.
var — lets Java figure out the type for local variables. Only works when you assign a value immediately.

Variables are the most basic building block of any Java program. You cannot write a single useful line without them.

The three types — local, instance, and static — seem similar at first. But once you understand scope and lifetime, each one has a clear and logical purpose.

Try writing the BankAccount program yourself. Add a new method. Add a new instance variable. Change the minimum balance constant and see it reflect everywhere.

That hands-on practice is what turns reading into understanding.

If you have a question — drop it in the comments below.

Thanks for reading. Keep building.

Java Data Types Explained — Simply, With Examples

DHANRAJ S — Fri, 29 May 2026 06:42:30 +0000

Hey!

Before we start — let me ask you something.

You are filling out a form. One field asks for your name. Another asks for your age. Another asks for your phone number. Another asks — are you a student? Yes or No.

All four fields take different kinds of data. Name is text. Age is a number. Phone number is digits. Yes or No is just true or false.

Java works exactly the same way.

Every piece of data has a type. And Java makes you say that type clearly before you use it.

That is what data types are. And by the end of this blog — every Java data type will make complete sense.

1. What Is a Data Type?

A data type tells Java two things.

First — what kind of value this variable holds.
Second — how much memory to give it.

int age = 25;

int — the type. Tells Java this is a whole number.
age — the name of the variable.
25 — the value.

Java reads this and thinks — "okay, age is a whole number. I will give it exactly enough memory for a whole number. Nothing more."

That is why data types matter. Java is efficient. It does not guess. You tell it exactly what you need.

2. Two Categories of Data Types

All data types in Java fall into two categories.

Primitive Data Types — basic, built-in types. They hold simple values directly.

Non-Primitive Data Types — complex types like String, Array, and Objects. They hold references to data.

Today we will focus on primitive types — because these are the foundation. Everything else builds on top of them.

Java has exactly 8 primitive data types. Let us go through each one.

3. The 8 Primitive Data Types — Overview

Type	What it stores	Size	Example
`byte`	Small whole number	1 byte	`10`
`short`	Medium whole number	2 bytes	`1500`
`int`	Whole number	4 bytes	`50000`
`long`	Very large whole number	8 bytes	`9999999999L`
`float`	Decimal number	4 bytes	`3.14f`
`double`	Precise decimal number	8 bytes	`3.14159265`
`char`	Single character	2 bytes	`'A'`
`boolean`	True or false	1 bit	`true`

Do not try to memorise all of this right now. Read through each one. It will click as you see examples.

4. Integer Types — Whole Numbers

These four types all store whole numbers. The difference is just how big the number can be.

byte

Stores numbers from -128 to 127.

byte temperature = 36;
byte smallNumber = -50;

System.out.println(temperature);  // 36

Use byte when you know the number will be very small. Saves memory.

Quick question for you.

What do you think happens if you try to store 200 in a byte?

byte b = 200;  // Error!

Java will give you a compile error. 200 is outside the range of -128 to 127. Java catches this mistake before your program even runs.

short

Stores numbers from -32,768 to 32,767.

short population = 25000;
short year = 2025;

System.out.println(year);  // 2025

Bigger than byte. Still smaller than int. Use it when your number fits in this range and memory matters.

int

The most commonly used integer type. Stores numbers from about -2 billion to 2 billion.

int age = 25;
int salary = 75000;
int distance = 1000000;

System.out.println(salary);  // 75000

When you are not sure which integer type to use — use int. It is the default choice for whole numbers in Java.

long

Stores very large numbers. When int is not big enough — use long.

long worldPopulation = 8000000000L;
long distanceToSun = 149600000000L;

System.out.println(worldPopulation);  // 8000000000

Notice the L at the end of the number. That is required. Without it — Java treats the number as an int and it overflows.

Quick question for you.

Why do we need L at the end of a long value?

By default, Java reads any whole number as an int. If the number is too big for an int — Java gets confused before it even assigns it. The L tells Java — "this is a long, not an int." Now Java handles it correctly.

5. Decimal Types — Numbers With a Dot

float

Stores decimal numbers. Less precise. Uses 4 bytes.

float price = 99.99f;
float height = 5.8f;

System.out.println(price);  // 99.99

Notice the f at the end. Same reason as L for long — Java reads decimal numbers as double by default. The f tells Java this is a float.

double

Stores decimal numbers. More precise than float. Uses 8 bytes.

double pi = 3.14159265358979;
double bankBalance = 150000.75;

System.out.println(pi);  // 3.14159265358979

No letter needed at the end. double is Java's default for decimal numbers.

Quick question for you.

When should you use float over double?

When memory is tight — like in embedded systems or when storing millions of values. float uses half the memory of double. But for most everyday programs — just use double. The extra precision is worth it.

6. char — Single Character

char stores exactly one character. Always use single quotes.

char grade = 'A';
char initial = 'R';
char symbol = '@';

System.out.println(grade);   // A
System.out.println(symbol);  // @

Always single quotes for char. Double quotes are for Strings.

char letter = 'A';    // correct
char letter = "A";    // wrong — this is a String, not a char

Something interesting about char — every character has a number behind it called a Unicode value.

char letter = 'A';
System.out.println((int) letter);  // 65

'A' is actually stored as the number 65. 'B' is 66. 'a' is 97.

You can even do arithmetic with chars.

char letter = 'A';
System.out.println((char)(letter + 1));  // B

7. boolean — True or False

boolean stores only two values — true or false. Nothing else.

boolean isLoggedIn = true;
boolean hasDiscount = false;
boolean isAdult = true;

System.out.println(isLoggedIn);   // true
System.out.println(hasDiscount);  // false

This is used everywhere — conditions, flags, checking states.

boolean isEven = (10 % 2 == 0);
System.out.println(isEven);  // true

Quick question for you.

What do you think boolean isEven = (7 % 2 == 0) gives?

7 % 2 gives 1 — the remainder when 7 is divided by 2. 1 == 0 is false. So isEven is false. 7 is not even.

8. Putting It All Together — One Example

Let us use all 8 types in one program.

public class DataTypes {
    public static void main(String[] args) {

        byte age = 25;
        short year = 2025;
        int salary = 75000;
        long worldPopulation = 8000000000L;

        float height = 5.9f;
        double pi = 3.14159265358979;

        char grade = 'A';
        boolean isStudent = false;

        System.out.println("Age: " + age);
        System.out.println("Year: " + year);
        System.out.println("Salary: " + salary);
        System.out.println("World Population: " + worldPopulation);
        System.out.println("Height: " + height);
        System.out.println("Pi: " + pi);
        System.out.println("Grade: " + grade);
        System.out.println("Is Student: " + isStudent);
    }
}

Output:

Age: 25
Year: 2025
Salary: 75000
World Population: 8000000000
Height: 5.9
Pi: 3.14159265358979
Grade: A
Is Student: false

Eight types. One program. All working together.

9. Type Casting — Converting One Type to Another

Sometimes you need to convert one type to another.

There are two kinds.

Widening — automatic, safe

Going from a smaller type to a bigger type. Java does this automatically.

int num = 100;
long bigNum = num;       // int to long — automatic
double decimal = num;    // int to double — automatic

System.out.println(bigNum);    // 100
System.out.println(decimal);   // 100.0

No data is lost. The smaller type fits perfectly inside the bigger one.

Narrowing — manual, you do it yourself

Going from a bigger type to a smaller type. You have to do this manually because data might be lost.

double price = 99.99;
int roundedPrice = (int) price;

System.out.println(roundedPrice);  // 99

(int) tells Java — "I know what I am doing. Convert this double to an int."

The .99 is cut off. Not rounded. Just cut. That is narrowing casting — you lose the decimal part.

Quick question for you.

What do you think (int) 9.9 gives? 9 or 10?

It gives 9. Java does not round — it truncates. Just drops everything after the decimal point. Keep that in mind.

10. Common Mistakes Beginners Make

Forgetting L for long

long big = 9999999999;   // Error — Java reads this as int, too big
long big = 9999999999L;  // Correct

Forgetting f for float

float price = 9.99;    // Error — Java reads this as double
float price = 9.99f;   // Correct

Using double quotes for char

char letter = "A";  // Error — this is a String
char letter = 'A';  // Correct

Storing a value outside the type's range

byte b = 200;   // Error — byte only goes up to 127
int i = 200;    // Correct

Quick Summary — 8 Types in Plain English

byte — tiny whole numbers. -128 to 127. Rare use.
short — small whole numbers. -32,768 to 32,767. Rare use.
int — your go-to whole number type. Use this by default.
long — very large whole numbers. Add L at the end.
float — decimal numbers, less precise. Add f at the end.
double — decimal numbers, more precise. Your go-to decimal type.
char — single character. Always use single quotes.
boolean — only true or false. Used in conditions everywhere.

Data types are the very foundation of Java. Every variable you ever create will have one.

The good news is — in practice, you use int, double, boolean, and char for 90% of everything. The others exist for specific situations.

Try writing the full program from section 8 yourself. Change the values. Try storing a number outside the range. See the error Java gives you. That hands-on experience will make all of this stick.

If you have a question — drop it in the comments below.

Thanks for reading. Keep building.

Java Explained — What It Is, Why It Exists, and How It Actually Runs

DHANRAJ S — Wed, 27 May 2026 14:31:52 +0000

Hey!

Let me ask you something.

You write a program on your Windows laptop. Your friend opens it on a Mac. Your college server runs Linux.

Does the program work on all three?

In most languages — no. You would need to rewrite or recompile it for each system.

Java said — why should that be a problem?

And that one idea changed everything.

1. What Is Java?

Java is a programming language created by James Gosling at Sun Microsystems in 1995.

It is one of the most widely used languages in the world. Android apps, banking systems, enterprise software, web backends — Java is behind a huge part of the technology we use every day.

But what makes Java different from other languages?

One line answers it.

Write once. Run anywhere.

You write Java code once. It runs on Windows, Mac, Linux, Android — without changing a single line.

That is not just a tagline. It is how Java actually works. We will see exactly how in a moment.

2. Why Java? — Before Java, What Was the Problem?

Quick question for you.

Imagine you are a developer in 1990. You write a program in C or C++.

Your program works perfectly on Windows. But your client uses a different operating system. What do you do?

You rewrite the code. Or recompile it specifically for that system. Sometimes both.

Every operating system speaks a different language at the hardware level. A program built for Windows cannot just run on Linux.

This was a real headache for developers and companies. Especially as the internet grew and software needed to run everywhere.

Java solved this with a clever idea — the Java Virtual Machine.

3. How Does Java Actually Run?

This is the part most beginners skip. But it is the most important part to understand.

Let us go step by step.

Step 1 — You write Java code

public class Hello {
    public static void main(String[] args) {
        System.out.println("Hello, World!");
    }
}

This is your source code. Saved as a .java file.

Step 2 — The compiler converts it to bytecode

When you compile your Java file — the Java compiler does not convert it to machine code for Windows or Mac or Linux.

It converts it to something called bytecode. Saved as a .class file.

Bytecode is not tied to any operating system. It is a middle language. Universal.

Step 3 — The JVM runs the bytecode

Every operating system has its own JVM — Java Virtual Machine — installed.

The JVM on Windows reads the bytecode and translates it for Windows.
The JVM on Mac reads the same bytecode and translates it for Mac.
The JVM on Linux does the same for Linux.

Your Java Code (.java)
        ↓
   Java Compiler
        ↓
   Bytecode (.class)
        ↓
  ┌─────┼─────┐
  ↓     ↓     ↓
 JVM   JVM   JVM
 Win   Mac  Linux

Same bytecode. Different JVMs. Works everywhere.

That is how "write once, run anywhere" actually works. The JVM does the translation work so you do not have to.

4. JDK, JRE, and JVM — What Is the Difference?

These three terms confuse every beginner. Let us clear them up simply.

JVM — Java Virtual Machine

Runs the bytecode. Every OS has its own JVM. This is what makes Java platform-independent.

JRE — Java Runtime Environment

JRE = JVM + libraries needed to run Java programs.

If you just want to run a Java program — install the JRE.

JDK — Java Development Kit

JDK = JRE + compiler + development tools.

If you want to write and compile Java programs — install the JDK.

Simple rule.

User who just runs Java apps → JRE.
Developer who writes Java code → JDK.

5. Your First Java Program — Let Us Read It

public class Hello {
    public static void main(String[] args) {
        System.out.println("Hello, World!");
    }
}

Quick question for you.

Before reading the explanation — can you guess what System.out.println does?

System.out.println("Hello, World!") — prints the text to the screen. Like print() in Python or console.log() in JavaScript.

public static void main(String[] args) — this is the entry point. Every Java program starts running from here. It is the first thing Java looks for when it runs your program.

public class Hello — in Java, everything lives inside a class. The class name must match the file name. This file must be saved as Hello.java.

6. Features of Java

These are the reasons Java has lasted 30 years and is still going strong.

Platform Independent

Already explained. Write once. Run anywhere. The JVM handles the rest.

Object Oriented

Everything in Java is built around objects and classes. This makes large programs easier to organize, reuse, and maintain.

Real world example — a Car class has properties like color and speed, and actions like start() and stop(). You create as many car objects as you need from that one class.

Strongly Typed

In Java — you must declare the type of every variable.

int age = 25;
String name = "Ravi";
double price = 99.99;

You cannot put a string where a number is expected. Java catches this mistake before your program even runs. That means fewer bugs in production.

Automatic Memory Management

In C or C++ — you manage memory yourself. You allocate it. You free it. Forget to free it — your program leaks memory and slows down.

Java has a garbage collector. It automatically cleans up memory that is no longer needed. You focus on the logic. Java handles the memory.

Multithreading

Java can run multiple tasks at the same time.

Think of a banking app. One thread handles your login. Another thread processes a transaction. Another thread refreshes your balance. All happening together — without one waiting for the other.

Java has built-in support for this.

Secure

Java runs inside the JVM — which acts as a sandbox. Your Java program cannot directly access your operating system or hardware without permission. This makes Java a safer choice for web and enterprise applications.

Robust

Java checks for errors at two stages — when you compile and when you run. It has strong exception handling. Programs do not just crash silently. Errors are caught and handled properly.

7. Where Is Java Used Today?

Quick question for you.

Can you guess which mobile operating system runs on Java?

Android. Every Android app was traditionally written in Java. Even today — Kotlin, the newer Android language, runs on the same JVM.

Beyond mobile — Java is used in:

Banking and finance systems — most major banks run Java backends
Web applications — Spring is one of the most popular backend frameworks, built on Java
Enterprise software — large companies like Amazon, LinkedIn, and Uber use Java in their backend
Big Data — Hadoop and Kafka, which process massive amounts of data, are written in Java
Embedded systems — Java runs on smart cards, set-top boxes, and other devices

8. Java vs Other Languages — A Simple Comparison

	Java	Python	JavaScript
Speed	Fast	Slower	Medium
Syntax	Verbose but clear	Very clean	Flexible
Typing	Strongly typed	Dynamically typed	Dynamically typed
Best for	Enterprise, Android, Big Data	Data science, scripting, AI	Web frontend and backend
Platform	JVM — runs anywhere	Interpreter per OS	Browser or Node.js
Learning curve	Moderate	Easy	Easy to start

Java is more verbose than Python. But that verbosity makes large codebases easier to read and maintain. When you are working in a team on a million-line codebase — clarity matters more than brevity.

Quick Summary — 5 Things to Remember

Java was created in 1995 — and is still one of the most used languages in the world. Banking, Android, enterprise software — Java is everywhere.
Write once, run anywhere — Java compiles to bytecode, not machine code. The JVM on each OS runs that bytecode. Same code. Every platform.
JDK to write code. JRE to run code. JVM to execute bytecode — install JDK if you are learning Java.
Strongly typed and object oriented — every variable has a type. Everything is built around classes and objects. This makes Java safe and organized.
Automatic garbage collection — Java manages memory for you. No manual allocation or freeing.

Java might look more complex than Python or JavaScript at first. More lines. More structure. More rules.

But that structure is exactly what makes Java reliable for large, serious applications.

Once you get comfortable with the syntax — you will appreciate how organized Java forces you to be.

Start with the Hello World program above. Then try creating a simple class with a few variables and methods. That is where Java starts to make sense.

If you have a question — drop it in the comments below.

Thanks for reading. Keep building.

Python Loops Explained — With a Frog Trying to Escape a Tank

DHANRAJ S — Tue, 26 May 2026 06:27:18 +0000

Hey!

Before we start — let me give you a small puzzle.

A frog is stuck at the bottom of a 50 feet tall tank.

Every day — it jumps up 2 feet.
Every night — it slides back down 1.25 feet.

How many days does it take for the frog to escape the tank?

Take a guess. Write down your answer.

We are going to solve this with Python loops. And by the end — you will understand loops better than most beginners do.

Let us start.

1. What Is a Loop?

A loop is a way to run the same code again and again — until a condition is met.

Think of it like an alarm clock.

It keeps ringing. Every minute. Every minute. Every minute. Until you wake up and turn it off.

That "until you turn it off" part — that is your condition.

In Python — there are two types of loops.

for loop — runs a fixed number of times
while loop — runs until a condition becomes false

2. The for Loop

A for loop runs for a specific number of times. You know the count before it starts.

for i in range(5):
    print(i)

Output:

range(5) gives numbers from 0 to 4. Five numbers. Loop runs five times.

Quick question for you.

What do you think range(1, 6) gives?

for i in range(1, 6):
    print(i)

Output:

range(start, stop) — starts at 1, stops before 6. So 1 to 5.

3. The while Loop

A while loop keeps running as long as a condition is true. You do not need to know the count upfront. It just keeps going until something changes.

count = 0

while count < 5:
    print(count)
    count += 1

Output:

while count < 5 — keep running as long as count is less than 5.

count += 1 — increase count by 1 every time. Without this — the loop runs forever.

Quick question for you.

What happens if you forget to write count += 1?

The count stays 0 forever. 0 < 5 is always true. The loop never stops. That is called an infinite loop. Your program hangs.

Always make sure your while loop has a way to eventually become false.

4. break and continue — Two Useful Keywords

break — stops the loop immediately.

for i in range(10):
    if i == 5:
        break
    print(i)

Output:

When i hits 5 — break exits the loop. 5, 6, 7, 8, 9 never print.

continue — skips the current step and goes to the next one.

for i in range(6):
    if i == 3:
        continue
    print(i)

Output:

When i is 3 — continue skips it. The loop continues from 4.

5. Now — The Frog Problem

Let us read it again carefully.

Tank height: 50 feet
Frog starts at: 0 feet
Day jump: +2 feet
Night slide: -1.25 feet
Question: How many days to escape?

Before you see the code — think about this.

What kind of loop should we use here — for or while?

We do not know how many days it will take. We keep going until the frog escapes.

That means — while loop. We run until the frog's position reaches 50 feet.

6. The Python Code

tankHeight = 50
nightSlide = 1.25
dayJump = 2
day = 0

while tankHeight > 0:
    tankHeight = tankHeight - dayJump + nightSlide
    day += 1

print(day)

Clean. Simple. Short.

Let us read it line by line.

tankHeight = 50 — the tank starts at 50 feet. This is the remaining height the frog needs to cover.

nightSlide = 1.25 — how much the frog slides back every night.

dayJump = 2 — how much the frog jumps every day.

day = 0 — day counter starts at zero.

while tankHeight > 0 — keep looping as long as there is tank height remaining.

tankHeight = tankHeight - dayJump + nightSlide — every loop reduces the remaining height. Frog jumps 2 feet up — so we subtract 2. But slides 1.25 feet back — so we add 1.25 back. Net reduction per day = 0.75 feet.

day += 1 — count the day.

print(day) — when the loop ends, print how many days it took.

Quick question for you.

Why do we write - dayJump + nightSlide and not - dayJump - nightSlide?

Because tankHeight is the remaining distance. When the frog jumps up — remaining distance goes down. So we subtract dayJump. When the frog slides back — remaining distance goes up again. So we add nightSlide back.

Subtracting progress. Adding back the slide. That is the logic.

7. What Is the Output?

Run it and see.

That is it. The frog escapes on day 49.

No extra print statements. No step-by-step logging. Just the answer — clean and direct.

Quick question for you.

Did you guess 49 at the start?

Most people guess something between 30 and 45. Because they think — "50 divided by 0.75 is about 66." But that formula is wrong. The frog does not slide back on the last day. So the actual answer is less.

The loop handles this correctly because it checks tankHeight > 0 after each full day including the slide. When the tank height goes to 0 or below — the loop stops and we count that day.

That is the beauty of loops. No formula needed. Just describe what happens each day — and let the loop repeat it until the condition is met.

8. What Did We Learn About Loops From This?

The frog problem taught us something important.

You do not always know how many times a loop will run.

Sometimes you just know the condition — "keep going until the frog escapes." That is a while loop.

Sometimes you know the exact count — "do this 10 times." That is a for loop.

And break is your emergency exit — when something happens mid-loop and you need to stop immediately.

In the frog problem — break is the moment the frog jumps out. We do not let it fall back. We stop right there.

Quick Summary — 5 Things to Remember

for loop — use when you know how many times to repeat. for i in range(n).
while loop — use when you do not know the count. Keep running until a condition is false.
break — exits the loop immediately. Used when the goal is reached mid-loop.
continue — skips the current step and moves to the next one.
Always have an exit condition in while loops — otherwise your loop runs forever and your program hangs.

Loops are everywhere in programming. Search results. Payments. Games. Animations. Any time something needs to repeat — there is a loop behind it.

The frog problem is a great way to practice because it has a real-world feel. Days passing. A goal to reach. A condition to check each step.

Try changing the numbers. Make the tank 200 feet. Make the frog jump 5 feet but slide back 4.9 feet. See how many days it takes.

Then try writing it without looking at the code above.

That is when you know loops have clicked.

If you have a question — drop it in the comments below.

Thanks for reading. Keep building.

Redux Explained — Why It Exists and How to Use It Simply

DHANRAJ S — Fri, 22 May 2026 09:18:22 +0000

Hey!

Before we start — let me show you a situation.

You are building a medium-sized React app. You have a logged-in user. Their name shows in the Navbar. Their profile shows on the Profile page. Their orders show on the Orders page.

All three need the same user data.

So you put the user in the top-level component and pass it down through props.

It works. But then your app grows.

More components need the user. More props get passed. More levels get added. You already learned about useContext — and yes, it helps.

But now imagine this.

Your app has a shopping cart. A notification system. A theme setting. A logged-in user. All of this is global data. All of it needs to be accessible from many places. All of it can change at any time.

You have multiple contexts. Multiple providers wrapping each other. Managing all these state changes becomes messy. Debugging becomes harder. "Which context changed and why?" becomes a real question.

That is the problem Redux solves.

1. What Is Redux?

Redux is a state management library.

It gives you one central place to store all your app's data. One single source of truth. Every component reads from it. Every component updates through it.

Think of it like a government database.

Every department — health, transport, education — does not keep its own separate records. They all read from and write to one central database. One source. Always accurate. Always in sync.

That central database is your Redux store.

2. The Three Core Ideas in Redux

Redux is built on three simple ideas. Understand these and everything else makes sense.

Store — the single source of truth

The store holds your entire app's state in one object.

{
  user: { name: "Ravi", role: "admin" },
  cart: { items: [], total: 0 },
  theme: "dark"
}

One object. Your whole app's state. Right there.

Action — describing what happened

An action is a plain object that describes what event just happened.

{ type: "ADD_TO_CART", payload: { id: 1, name: "Laptop", price: 50000 } }
{ type: "REMOVE_FROM_CART", payload: 1 }
{ type: "LOGOUT_USER" }

type — what happened.
payload — any extra data needed.

You never change the store directly. You send an action and say "this happened."

Reducer — deciding what changes

The reducer is a function that takes the current state and an action — and returns the new state.

function cartReducer(state = { items: [] }, action) {
  switch (action.type) {
    case "ADD_TO_CART":
      return { items: [...state.items, action.payload] };
    case "REMOVE_FROM_CART":
      return { items: state.items.filter(item => item.id !== action.payload) };
    default:
      return state;
  }
}

Sound familiar? Yes — same idea as useReducer. Redux takes this concept and makes it work at the app level.

3. The Redux Flow — How It All Connects

This is the part most beginners find confusing. Let us make it crystal clear.

User does something
      ↓
Component dispatches an Action
      ↓
Reducer receives Action + current State
      ↓
Reducer returns new State
      ↓
Store updates
      ↓
All components that need that data re-render

One direction. Always. No shortcuts.

This is called unidirectional data flow. And it is what makes Redux so predictable and easy to debug.

Quick question for you.

Why do you think having one direction for data flow makes debugging easier?

Because you always know where to look. Something went wrong? Check what action was dispatched. Check what the reducer did with it. The trail is always clear. No guessing which component updated which state.

4. Setting Up Redux in a React App

Modern Redux uses Redux Toolkit — the official recommended way. It removes a lot of the old boilerplate.

Install it:

npm install @reduxjs/toolkit react-redux

5. A Simple Example — Counter With Redux

Let us build the simplest possible Redux example. A counter.

Step 1 — Create a slice

A slice is a piece of your Redux store. It holds the state and the reducers for one feature.

// store/counterSlice.js
import { createSlice } from "@reduxjs/toolkit";

const counterSlice = createSlice({
  name: "counter",
  initialState: { count: 0 },
  reducers: {
    increment(state) {
      state.count += 1;
    },
    decrement(state) {
      state.count -= 1;
    },
    reset(state) {
      state.count = 0;
    }
  }
});

export const { increment, decrement, reset } = counterSlice.actions;
export default counterSlice.reducer;

createSlice handles the action creators and reducer for you. No need to write them separately.

Step 2 — Create the store

// store/store.js
import { configureStore } from "@reduxjs/toolkit";
import counterReducer from "./counterSlice";

const store = configureStore({
  reducer: {
    counter: counterReducer
  }
});

export default store;

Step 3 — Provide the store to your app

// main.jsx
import { Provider } from "react-redux";
import store from "./store/store";

ReactDOM.createRoot(document.getElementById("root")).render(
  <Provider store={store}>
    <App />
  </Provider>
);

Provider makes the store available to every component inside it. Just like Context Provider — but for Redux.

Step 4 — Use it in a component

// Counter.jsx
import { useSelector, useDispatch } from "react-redux";
import { increment, decrement, reset } from "./store/counterSlice";

function Counter() {
  const count = useSelector(state => state.counter.count);
  const dispatch = useDispatch();

  return (
    <div>
      <p>Count: {count}</p>
      <button onClick={() => dispatch(increment())}>+1</button>
      <button onClick={() => dispatch(decrement())}>-1</button>
      <button onClick={() => dispatch(reset())}>Reset</button>
    </div>
  );
}

useSelector — reads data from the store. Like saying "give me this piece of the store."

useDispatch — gives you the dispatch function. You use it to send actions to the store.

Quick question for you.

Can you use useSelector in two different components — and both will always show the same up-to-date value?

Yes. Because both are reading from the same store. When the store updates — both components re-render with the latest value automatically. That is the power of a single source of truth.

6. What Does the Full Flow Look Like?

Let us trace through clicking the +1 button:

User clicks +1
      ↓
dispatch(increment()) fires
      ↓
Redux sends action { type: "counter/increment" } to the reducer
      ↓
Reducer runs: state.count += 1
      ↓
Store updates: count is now 1
      ↓
Counter component re-renders
      ↓
Screen shows: Count: 1

Every step is visible. Every step is traceable.

7. useContext vs Redux — Which One to Use?

This is the question everyone asks. Both manage global state. So when do you use which?

	useContext	Redux
Best for	Simple global data — theme, user, language	Complex state with many interactions
Setup	Very simple	More setup needed
Dev tools	No	Yes — powerful Redux DevTools
Scalability	Gets messy at large scale	Built for large apps
When state changes	All context consumers re-render	Only components that use that slice re-render

Simple rule.

Small app with simple global state — useContext is enough.

Large app with complex state, many features, many interactions — Redux is worth it.

Do not reach for Redux on day one. Start simple. Add Redux when you actually feel the pain of managing state without it.

8. Why Redux Is Still Worth Learning

You might be thinking — "this feels like a lot of setup for a counter."

Fair point. For a counter — it is overkill.

But Redux is used in large production apps for real reasons.

Redux DevTools let you time-travel through every state change. You can replay actions, inspect what changed, and debug issues in seconds.

Every state change has a clear action and a clear trail. No mystery updates. No wondering which component changed what.

Teams working on the same codebase can follow the same pattern. Everyone knows where the state is and how it changes.

Quick Summary — 5 Things to Remember

Redux is a central store for all your app state — one place, one source of truth, every component reads from it.
Actions describe what happened — you never change the store directly. You dispatch an action and let the reducer handle it.
Reducers decide the new state — they take the current state and the action, and return what the state should look like next.
useSelector reads from the store. useDispatch sends actions — these two hooks are how your components talk to Redux.
Use Redux when your app is actually complex — for simple apps, useContext is enough. Redux shines when state management becomes genuinely hard.

Redux felt intimidating when it first came out. The old way had a lot of boilerplate. Redux Toolkit fixed most of that.

Today — setting up Redux is straightforward. And once you see the DevTools in action, time-travelling through state changes, you will understand why large teams rely on it.

Try the counter example. Add a new slice for a theme toggle. See how two completely separate slices live in the same store and work independently.

That is the moment Redux starts to make sense.

If you have a question — drop it in the comments below.

Thanks for reading. Keep building.

useRef in React — Why It Exists and How to Use It Simply

DHANRAJ S — Wed, 20 May 2026 17:54:42 +0000

Hey!

Let me ask you something.

You have an input field in React. When the page loads — you want the cursor to automatically focus on that input. So the user can start typing right away without clicking it first.

How do you do that?

In plain JavaScript it is simple.

document.getElementById("myInput").focus();

But in React — you do not touch the DOM directly like that. React manages the DOM for you.

So how do you access a real DOM element in React?

That is exactly what useRef is for.

1. What Is useRef?

useRef is a React hook that gives you a way to directly access a DOM element or store a value that does not cause a re-render when it changes.

It returns an object with one property — current.

const myRef = useRef(null);

// myRef looks like this:
// { current: null }

When you attach it to a DOM element — current holds that element. You can then do anything you would normally do with a DOM element.

Think of it like putting a sticky note on a specific element in your app. Whenever you need that element — you check the sticky note and find it instantly.

2. The Problem Without useRef

Let us say you want to focus an input when the page loads.

Without useRef — you might try this:

function SearchPage() {
  document.getElementById("search").focus(); // too early — element not ready yet

  return <input id="search" type="text" placeholder="Search..." />;
}

This does not work.

When this line runs — the input is not in the DOM yet. React has not rendered it. So getElementById returns null and .focus() crashes.

useRef solves this cleanly.

3. The Syntax

import { useRef } from "react";

function MyComponent() {
  const inputRef = useRef(null);

  return <input ref={inputRef} type="text" />;
}

useRef(null) — creates a ref with current set to null at first.

ref={inputRef} — you attach it to the element. Once React renders the input — inputRef.current points to that real DOM element.

Now you can call any DOM method on it — .focus(), .blur(), .scrollIntoView().

4. Example 1 — Auto Focus Input

import { useRef, useEffect } from "react";

function SearchPage() {
  const inputRef = useRef(null);

  useEffect(() => {
    inputRef.current.focus();
  }, []);

  return (
    <div>
      <input ref={inputRef} type="text" placeholder="Search..." />
    </div>
  );
}

What happens here:

Page loads
  → React renders the input
  → useEffect runs once
  → inputRef.current is now the real input element
  → .focus() puts the cursor there automatically

The user lands on the page. Cursor is already in the input. Ready to type.

Quick question for you.

Why do we put .focus() inside useEffect and not directly in the component body?

Because the component body runs before React renders anything to the screen. The input does not exist yet at that point. useEffect runs after the render — so the element is there and ready.

5. Example 2 — Store a Value Without Re-Rendering

This is the second use of useRef — and it surprises most beginners.

useRef can also store any value — not just DOM elements. And when that value changes — the component does not re-render.

That is the key difference from useState.

import { useRef, useState } from "react";

function Timer() {
  const [isRunning, setIsRunning] = useState(false);
  const intervalRef = useRef(null);

  function start() {
    setIsRunning(true);
    intervalRef.current = setInterval(() => {
      console.log("tick");
    }, 1000);
  }

  function stop() {
    setIsRunning(false);
    clearInterval(intervalRef.current);
  }

  return (
    <div>
      <p>{isRunning ? "Running..." : "Stopped"}</p>
      <button onClick={start}>Start</button>
      <button onClick={stop}>Stop</button>
    </div>
  );
}

intervalRef stores the timer ID from setInterval.

When you click Stop — intervalRef.current gives you that ID and clearInterval stops the timer.

Quick question for you.

Why not use useState to store the interval ID instead of useRef?

Because updating state causes a re-render. You do not need the screen to update when the interval ID changes — you just need to remember it so you can clear it later. useRef stores it silently. No re-render. No side effects.

6. useRef vs useState — The Key Difference

This is the thing that confuses most beginners.

Both store values. But they behave very differently.

	useState	useRef
Re-renders on change	Yes	No
Shows value on screen	Yes	No
Access DOM elements	No	Yes
Best for	UI values — count, input, toggle	DOM access, timers, previous values

Simple rule.

If changing the value should update what the user sees — use useState.

If you just need to remember something quietly in the background — use useRef.

7. One Common Mistake

Reading ref.current too early — before React has rendered the element.

function MyComponent() {
  const inputRef = useRef(null);

  console.log(inputRef.current); // null — element not rendered yet

  useEffect(() => {
    console.log(inputRef.current); // the real input element — safe to use here
  }, []);

  return <input ref={inputRef} />;
}

Always access ref.current inside useEffect or inside an event handler — never directly in the component body.

By the time useEffect runs or a user clicks a button — React has already rendered the element. It is safe.

Quick Summary — 4 Things to Remember

useRef gives you access to DOM elements — attach it with the ref prop and use ref.current to call DOM methods like .focus().
useRef stores values without re-rendering — perfect for storing timer IDs, previous values, or anything you need to remember but not show on screen.
ref.current starts as null — it only gets the real element after React renders it. Always access it inside useEffect or event handlers.
useRef vs useState — useState triggers re-renders and updates the UI. useRef stores silently. Use the right one for the right job.

useRef is one of those hooks that feels unnecessary at first — until you need to focus an input or stop a timer and you realise it is the cleanest way to do it.

Try the auto focus example. Build it. Load the page. See the cursor land in the input automatically. Then try the timer. Start it. Stop it. See how the interval ID is stored and cleared cleanly.

That hands-on time will make it stick.

If you have a question — drop it in the comments below.

Thanks for reading. Keep building.