DEV Community: Hariharan S J

What Really Happens When You Create an Object in Java? Understanding Constructors and Packages

Hariharan S J — Wed, 03 Jun 2026 13:21:54 +0000

1.Introduction

Have you ever created an object in Java and wondered what happens behind the scenes the moment that object comes to life?

When you write something as simple as:

Student s1 = new Student();

Java doesn't just magically create an object. It first invokes a special mechanism called a constructor, which prepares the object and gets it ready for use. Whether you're assigning default values or passing custom data during object creation, constructors play a crucial role in every Java application.

But creating objects is only part of the story.

As applications grow from a few classes to hundreds or even thousands, managing code becomes a challenge. Imagine trying to find a single class in a project where every file is stored in the same folder. That's where packages come in. Packages help developers organize code, avoid naming conflicts, and build scalable applications that are easier to maintain.

In this article, we'll explore the different types of constructors in Java, understand how they work, and learn how packages help structure real-world Java projects. By the end, you'll have a solid understanding of two fundamental concepts that every Java developer uses daily.

In my previous blog i had discussed what is constructor? , why constructor is needed in this blog we are going to discuss about the Types of Constructor and Packages

2.Types of Constructors in Java

Java mainly provides three types of constructors:

Default Constructor
No-Argument Constructor
Parameterized Constructor

1. Default Constructor

A default constructor is automatically provided by the Java compiler when no constructor is explicitly written.

If we do not create any constructor, the Java compiler automatically creates a no-arg constructor during the execution of the program.

This constructor is called the default constructor.

Example

class Student {

    int id;
    String name;

    public static void main(String[] args) {

        Student s1 = new Student();

        System.out.println(s1.id);
        System.out.println(s1.name);
    }
}

Output

0
null

Explanation

Since no constructor was defined, Java automatically generated a default constructor and assigned default values to instance variables.

2. No-Argument Constructor

A no-argument constructor is created by the programmer and does not accept any parameters

Similar to methods, a Java constructor may or may not have any parameters (arguments).

If a constructor does not accept any parameters, it is known as a no-argument constructor. For example,

Example

class Student {

    int id;
    String name;

    Student() {
        id = 101;
        name = "Hari";
    }

    public static void main(String[] args) {

        Student s1 = new Student();

        System.out.println(s1.id);
        System.out.println(s1.name);
    }
}

Output

101
Hari

Why Use It?

A no-argument constructor allows us to initialize objects with custom default values instead of Java's built-in defaults.

3. Parameterized Constructor

A parameterized constructor accepts values during object creation.

A Java constructor can also accept one or more parameters. Such constructors are known as parameterized constructors (constructors with parameters).

Example

class Student {

    int id;
    String name;

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

    public static void main(String[] args) {

        Student s1 = new Student(101, "Hari");

        System.out.println(s1.id);
        System.out.println(s1.name);
    }
}

Output

101
Hari

Why Use It?

Parameterized constructors allow each object to have different values during creation.

Student s1 = new Student(101, "Hari");
Student s2 = new Student(102, "John");
Student s3 = new Student(103, "David");

Each object stores unique data.

Constructor Overloading

Java allows multiple constructors within the same class as long as their parameter lists are different.

Example

class Student {

    Student() {
        System.out.println("No Argument Constructor");
    }

    Student(String name) {
        System.out.println("Parameterized Constructor");
    }

    public static void main(String[] args) {

        Student s1 = new Student();
        Student s2 = new Student("Hari");
    }
}

Output

No Argument Constructor
Parameterized Constructor

This feature is known as Constructor Overloading.

3.What is a Package in Java?

A package is a collection of related classes, interfaces, and sub-packages.

Think of a package as a folder in your computer.

Just as folders help organize files, packages help organize Java classes.

A package in Java is a mechanism to group related classes, interfaces, and sub-packages into a single unit. Packages help organize large applications, avoid naming conflicts, provide access protection, and make code modular and maintainable.

Avoiding name conflicts (two classes with the same name can exist in different packages)
Providing access control using public, protected, and default access
Reusability: packaged code can be imported and used anywhere
Encouraging modular programming

4.Why Do We Need Packages?

Packages provide several advantages:

1. Better Code Organization

Without packages:

Student.java
Employee.java
Customer.java
Order.java

With Packages

com.company.student
com.company.employee
com.company.order

Everything becomes easier to manage.

2. Prevent Naming Conflicts

Two developers might create classes with the same name.

Example:

student.Student
employee.Student

Packages help Java identify which class is being used.

3. Access Protection

Packages help control visibility of classes and members using access modifiers.

Types of Packages

Java provides two types of packages:

1. Built-in Packages

These are packages provided by Java itself.

Examples:

java.lang(TBD)
java.util(TBD)
java.io(TBD)
java.sql(TBD)

2. User-Defined Packages

Developers can create their own packages.

Creating a Package

package college;

public class Student {

    public void display() {
        System.out.println("Inside Student Class");
    }
}

Using the Package

import college.Student;

public class Main {

    public static void main(String[] args) {

        Student s = new Student();

        s.display();
    }
}

Package Naming Convention

Java package names usually follow reverse domain naming.

Example:

com.google
com.microsoft
com.amazon
org.apache

This helps avoid naming conflicts in large applications.

5.Final Thoughts

Constructors and packages may seem like small Java concepts at first, but they play a huge role in real-world application development.

Constructors ensure that objects are properly initialized when created, while packages help organize code into meaningful structures.

As your Java projects become larger and more complex, understanding these two concepts will help you write cleaner, more maintainable, and professional-quality code.

Master constructors to control object creation. Master packages to control project organization. Together, they form a strong foundation for becoming an effective Java developer.

Reference

(https://www.geeksforgeeks.org/java/packages-in-java/)

(https://www.programiz.com/java-programming/constructors)

One While Loop, Seven Patterns, Endless Learning

Hariharan S J — Wed, 03 Jun 2026 10:06:11 +0000

1.Introduction

Have you ever noticed that most beginners can write a while loop, but struggle when asked to create a simple number pattern?

The problem isn't the syntax.

It's understanding how numbers change from one iteration to the next.

A sequence like 1 2 3 4 5 may look different from 1 3 5 7 9 or 15 12 9 6 3, but behind the scenes, they all follow the same fundamental principle: start with a value, repeat a process, and update that value in a predictable way.

This is exactly why pattern programs are so popular among programmers. They don't just teach loops—they train your brain to think logically, identify sequences, and understand how a program evolves step by step.

In this article, we'll use Python's while loop to build a variety of number patterns, from simple counting sequences to reverse and alternating patterns. More importantly, we'll focus on the logic behind each pattern so that by the end, you won't just know how to print these patterns—you'll know how to create your own.

2.Why Learn Patterns?

Many beginners try to memorize pattern programs.

That's the wrong approach.

Instead, focus on understanding:

What is changing in each iteration?

Once you understand that, any pattern becomes easy to build.

Let's look at some examples.

Pattern 1: Repeating the Same Number

Output

1 1 1 1 1

Program

no = 1

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

How It Works

The loop runs 5 times.
We always print 1.
The variable no is only used to count the iterations.

Pattern 2: Counting Numbers

Output

1 2 3 4 5

Program

no = 1

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

How It Works

We start from 1.
After every iteration, we increase the value by 1.
The loop stops when the value becomes greater than 5.

Pattern 3: Odd Numbers

Output

1 3 5 7 9

Program

no = 1

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

How It Works

Odd numbers have a difference of 2.
Instead of increasing by 1, we increase by 2.

Pattern 4: Multiples of 3

Output

3 6 9 12 15

Program

no = 3

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

How It Works

We start from 3.
Every next value is 3 more than the previous value.

Pattern 5: Reverse Multiples of 3

Output

15 12 9 6 3

Program

no = 15

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

How It Works

We start from the largest value.
Instead of incrementing, we decrement by 3.

Pattern 6: Reverse Even Numbers

Output

10 8 6 4 2

Program

no = 10

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

How It Works

We begin with 10.
Every iteration subtracts 2.
This produces even numbers in reverse order.

Pattern 7: Reverse Odd Numbers

Output

9 7 5 3 1

Program

no = 9

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

How It Works

We start from the largest odd number.
We subtract 2 in every iteration.
The sequence continues until 1.

The Hidden Pattern Behind All Patterns

If you look carefully, every program follows the same structure:

starting_value

while condition:
    print(value)
    update_value

The only things that change are:

Starting value
Condition
Increment or decrement

That's it.

Once you understand these three components, creating new patterns becomes much easier.

Final Takeaway

Pattern programs are not about printing numbers on the screen. They are exercises that train your brain to recognize sequences, understand loop behavior, and think logically.

The moment you stop memorizing patterns and start identifying what changes in each iteration, you'll be able to create your own patterns confidently.

Learn the logic, not the pattern. That's where real programming begins.

Java Constructors Demystified: What Happens Before Your Object Exists?

Hariharan S J — Tue, 02 Jun 2026 14:50:36 +0000

1.Introduction

Have you ever wondered what actually happens when you write:

SuperMarket product = new SuperMarket("Noodles", 50);

We all know that an object gets created. But what happens behind the scenes? Where does the memory come from? When are the values assigned? And why does Java automatically call a constructor without us explicitly invoking it?

When I first learned constructors, I thought they were just special methods used to initialize objects. But after experimenting with object creation, default values, the this keyword, and constructor parameters, I discovered that constructors are much more than that—they are the starting point of an object's lifecycle.

In this blog, we'll go beyond the textbook definition of constructors. We'll explore what really happens when an object is created, why this is important, how Java assigns default values, and some beginner mistakes that can silently break your code.

By the end of this article, you'll not only know what a constructor is, but also why it behaves the way it does behind the scenes.

Let's create our first object and uncover the magic that happens the moment we use the new keyword.

2.What is a Constructor?

A constructor is used in the creation of an object that is an instance of a class. Typically it performs operations required to initialize the class before methods are invoked or fields are accessed. Constructors are never inherited.

A constructor in Java is a special member that is called when an object is created. It initializes the new object’s state. It is used to set default or user-defined values for the object's attributes

A constructor in Java is a special method that is used to initialize objects.

The constructor is called when an object of a class is created.

It can be used to set initial values for object attributes:

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

Syntax

class SuperMarket {

    SuperMarket() {
        System.out.println("Constructor Called");
    }
}

Creating an Object

SuperMarket product = new SuperMarket();

Output

Constructor Called

The moment the object is created using the new keyword, Java automatically invokes the constructor.

3.Rules of a Constructor

A constructor has a few important rules:

1. Constructor name must be the same as the class name

class SuperMarket {

    SuperMarket() {

    }
}

2. Constructors do not have a return type

Correct

SuperMarket() {

}

Incorrect

void SuperMarket() {

}

The second example is not a constructor. It is a normal method.

4.Why Do We Need Constructors?

Imagine creating an object and manually assigning values every time.

SuperMarket product1 = new SuperMarket();
product1.name = "Noodles";
product1.price = 50;

SuperMarket product2 = new SuperMarket();
product2.name = "Shampoo";
product2.price = 150;

This works, but it becomes repetitive.

Instead, constructors allow us to initialize object-specific values immediately during object creation.

class SuperMarket {

    String name;
    int price;

    SuperMarket(String name, int price) {
        this.name = name;
        this.price = price;
    }
}

Now we can simply write:

SuperMarket product1 = new SuperMarket("Noodles", 50);
SuperMarket product2 = new SuperMarket("Shampoo", 150);

Cleaner, safer, and easier to maintain.

5.Why Is the Constructor Called Twice?

Consider this code:

SuperMarket product1 = new SuperMarket("abc", 20);
SuperMarket product2 = new SuperMarket("xyz", 2000);

Constructor:

SuperMarket(String name, int price) {
    System.out.println("Are you constructor?");
}

Output:

Are you constructor?
Are you constructor?

Many beginners get confused here.

The reason is simple:

One object = One constructor call
Two objects = Two constructor calls

Every time you use the new keyword, Java creates a new object and invokes the constructor.

6.The Mystery of this

Consider the following code:

class SuperMarket {

    String name;
    int price;

    SuperMarket(String name, int price) {
        this.name = name;
        this.price = price;
    }
}

Here:

this.name

refers to the instance variable.

While:

name

refers to the constructor parameter.

So:

this.name = name;

Means:

instanceVariable = parameter;

7.What Happens If We Remove this?

Suppose we write:

SuperMarket(String name, int price) {
    name = name;
    price = price;
}

At first glance, it looks correct.

But Java interprets it as:

parameter = parameter;
parameter = parameter;

The instance variables never receive the values.

8.Then Why Do We See null and 0?

Let's look at the class:

class SuperMarket {

    String name;
    int price;
}

Even though we never assigned values, Java still prints:

null
0

Why?

Because Java automatically assigns default values to instance variables.

9.What Actually Happens During Object Creation?

When Java executes:

new SuperMarket("Noodles", 50);

The JVM follows these steps:

Step 1

Memory is allocated for the object.

Step 2

Default values are assigned.

name = null
price = 0

Step 3

Field initializers are executed (if any).

String name = "Python";

Step 4

Constructor executes.

SuperMarket(String name, int price) {
    this.name = name;
    this.price = price;
}

Final flow:

Object Creation
       ↓
Default Values
       ↓
Field Initializers
       ↓
Constructor Execution

This order is extremely important for understanding how Java objects are initialized.

10.Final Takeaway

A constructor is not just a special method—it is the starting point of an object's life cycle.

Whenever an object is created:

Memory is allocated.
Default values are assigned.
Field initializers run.
The constructor executes.
The object becomes ready for use.

Understanding constructors also helps you understand other important concepts like this, object initialization, inheritance, and super() TBD.

If you're learning Java, mastering constructors is one of the best investments you can make before moving deeper into Object-Oriented Programming.

Strong Java Starts with Strong Fundamentals

Hariharan S J — Fri, 29 May 2026 06:26:01 +0000

1.Introduction

Programming languages come and go. Technologies change every year.
But even after decades, Java still powers millions of applications around the world — from banking systems and Android apps to enterprise software used by giant companies.

The interesting part?
Every advanced Java application starts with just a few basic concepts.

Before learning frameworks, APIs, or backend development, every Java developer must first understand:

How classes are declared
What data types actually mean
How fields store and manage data inside objects

These may look like beginner topics, but they form the backbone of Java programming. If these fundamentals are strong, learning advanced concepts becomes much easier.

In this blog, we’ll break down Java classes, primitive and non-primitive data types, and fields in a simple and beginner-friendly way with clear examples.

2.Classes, Data Types, and Fields in Java

Java is one of the most popular programming languages in the world. From Android apps to enterprise software, Java is used everywhere because of its simplicity, security, and platform independence.

Before building real-world applications, every Java developer must understand three important fundamentals:

How to declare a class correctly
Types of data types in Java
What fields are and how they work

Let’s explore them one by one.

3. Rules for Declaring a Class in Java

A class is the blueprint of an object.
In Java, everything revolves around classes.

Basic Syntax

class Student {

}

4.Important Rules for Declaring a Class

1. Class Name Should Start with a Letter

Correct:

class Employee {

}

Wrong:

class 123Employee {

}

2. Java is Case Sensitive

class Student {

}

class student {

}

Both are considered different classes.

3. Spaces Are Not Allowed in Class Names

Wrong:

class My Class {

}

Correct:

class MyClass {

}

4. Special Characters Are Not Allowed (Except _ and $)

Correct:

class Student_Data {

}

Wrong:

class Student@Data {

}

5. File Name and Public Class Name Must Be Same

public class Car {

}

The file name must be:

Car.java

Otherwise Java will throw an error.

4.Data Types in Java

Data types define what kind of value a variable can store.

Java mainly has two categories of data types:

Primitive Data Types
Non-Primitive Data Types

Primitive Data Types

Primitive data types are predefined by Java.
They store simple values directly.

Java has 8 primitive data types.

1. byte

The byte data type is an 8-bit signed two's complement integer. It has a minimum value of -128 and a maximum value of 127 (inclusive). The byte data type can be useful for saving memory in large arrays, where the memory savings actually matters. They can also be used in place of int where their limits help to clarify your code; the fact that a variable's range is limited can serve as a form of documentation.

byte age = 25;

Size: 1 byte

2. short

The short data type is a 16-bit signed two's complement integer. It has a minimum value of -32,768 and a maximum value of 32,767 (inclusive). As with byte, the same guidelines apply: you can use a short to save memory in large arrays, in situations where the memory savings actually matters.

short salary = 20000;

Size: 2 bytes

3. int

By default, the int data type is a 32-bit signed two's complement integer, which has a minimum value of -231 and a maximum value of 231-1. In Java SE 8 and later, you can use the int data type to represent an unsigned 32-bit integer, which has a minimum value of 0 and a maximum value of 232-1. Use the Integer class to use int data type as an unsigned integer. See the section The Number Classes for more information. Static methods like compareUnsigned, divideUnsigned etc have been added to the Integer class to support the arithmetic operations for unsigned integers.

int marks = 95;

Size: 4 bytes

4. long

The long data type is a 64-bit two's complement integer. The signed long has a minimum value of -263 and a maximum value of 263-1. In Java SE 8 and later, you can use the long data type to represent an unsigned 64-bit long, which has a minimum value of 0 and a maximum value of 264-1. Use this data type when you need a range of values wider than those provided by int. The Long class also contains methods like compareUnsigned, divideUnsigned etc to support arithmetic operations for unsigned long.

long population = 8000000000L;

Size: 8 bytes

5. float

The float data type is a single-precision 32-bit IEEE 754 floating point. Its range of values is beyond the scope of this discussion, but is specified in the Floating-Point Types, Formats, and Values section of the Java Language Specification. As with the recommendations for byte and short, use a float (instead of double) if you need to save memory in large arrays of floating point numbers. This data type should never be used for precise values, such as currency. For that, you will need to use the java.math.BigDecimal class instead. Numbers and Strings covers BigDecimal and other useful classes provided by the Java platform.

float price = 99.5f;

Size: 4 bytes

6. double

The double data type is a double-precision 64-bit IEEE 754 floating point. Its range of values is beyond the scope of this discussion, but is specified in the Floating-Point Types, Formats, and Values section of the Java Language Specification. For decimal values, this data type is generally the default choice. As mentioned above, this data type should never be used for precise values, such as currency.

double pi = 3.141592653;

Size: 8 bytes

7. char

The char data type is a single 16-bit Unicode character. It has a minimum value of '\u0000' (or 0) and a maximum value of '\uffff' (or 65,535 inclusive).

char grade = 'A';

Size: 2 bytes

8. boolean

The boolean data type has only two possible values: true and false. Use this data type for simple flags that track true/false conditions. This data type represents one bit of information, but its "size" isn't something that's precisely defined.

boolean isJavaFun = true;

Non-Primitive Data Types

Non-primitive data types are created by programmers or provided by Java.

They store references instead of actual values.

Examples:

String
Arrays (TBD)
Classes
Interfaces (TBD)
Objects

Non-primitive data types are called reference types because they refer to objects.

The main differences between primitive and non-primitive data types are:

Primitive types in Java are predefined and built into the language, while non-primitive types are created by the programmer (except for String).
Non-primitive types can be used to call methods to perform certain operations, whereas primitive types cannot.
Primitive types start with a lowercase letter (like int), while non-primitive types typically starts with an uppercase letter (like String).
Primitive types always hold a value, whereas non-primitive types can be null.

String Example

String name = "Hari";

Class Object Example

class Student {

}

Student s1 = new Student();

5.Final Takeaway

Every expert Java developer once started with the basics.
Understanding classes, data types, and fields may seem simple at first, but these concepts are the foundation of everything you build in Java.

A class gives structure to your program.
Data types help Java understand and manage data efficiently.
Fields define the properties that make every object unique.

When your fundamentals are strong, learning advanced topics like objects, constructors, inheritance, collections, JDBC, Spring Boot, and backend development becomes much easier.

So don’t rush through the basics.
Master them.

Because strong Java developers are built on strong fundamentals.

Reference

(https://docs.oracle.com/javase/tutorial/java/nutsandbolts/datatypes.html)

(https://www.w3schools.com/java/java_data_types_non-prim.asp)

From Railway Stations to Police Chase — Master Python While Loops

Hariharan S J — Thu, 28 May 2026 11:17:26 +0000

1.Mastering while Loops in Python with Real-Time Examples

Programming becomes interesting when we connect logic with real-world situations.
Instead of learning loops with boring numbers, let’s understand Python while loops using practical examples like:

Finding railway stations
Detecting common multiples
Catching a thief

In this blog, we’ll break down multiple Python programs step-by-step and understand how loops actually work behind the scenes.

2.Example 1 — Finding Numbers Divisible by 3 and 5

Program

station_no = 1

while station_no <= 30:
    if station_no % 3 == 0 and station_no % 5 == 0:
        print(station_no)

    station_no = station_no + 1

Output

15
30

Explanation

Here:

station_no starts from 1
The loop runs until 30
We check:

station_no % 3 == 0

AND

station_no % 5 == 0

If both are true, the number is printed.

3.What Does % Mean?

% is called the modulus operator.

It returns the remainder.

Example:

15 % 3 = 0

Because 15 is perfectly divisible by 3.

4.Example 2 — Finding the First Matching Station using break

Program

station_no = 1

while station_no <= 300:
    if station_no % 3 == 0 and station_no % 5 == 0:
        print(station_no)
        break

    station_no = station_no + 1

Output

5.What is break?

The break statement in Python is used to exit or "break" out of a loop (either for or while loop) prematurely, before the loop has iterated through all its items or reached its condition. When the break statement is executed, the program immediately exits the loop, and the control moves to the next line of code after the loop.

The break keyword is used to break out a for loop, or a while loop.

Without break, the loop would print:

But with break, the loop stops after finding the first matching value.

6.Example 3 — Unknown Number of Stations using while True

Program

station_no = 1

while True:  # Total no. of stations unknown

    if station_no % 18 == 0 and station_no % 62 == 0:
        print(station_no)
        break

    station_no = station_no + 1

Output

Why while True?

Sometimes we don't know:

how many times the loop should run
where the answer exists

So we create an infinite loop using:

while True:

Then stop it manually using break.

7.Example 4 — Police Catching a Thief

Program

while True:

    police = police + 5
    thief = thief + 2

    if police >= thief:
        print(police)
        break

Concept Behind the Program

This is a beautiful real-world simulation.

Police speed increases by 5
Thief speed increases by 2

The loop runs continuously.

Once:

police >= thief

The thief gets caught.

Important Note

Before running this program, initialize the variables.

Example:

police = 0
thief = 20

Complete Program:

police = 0
thief = 20

while True:

    police = police + 5
    thief = thief + 2

    if police >= thief:
        print(police)
        break

Output

8.Why These Programs Matter

Most beginners think loops are difficult.

But once you connect loops with:

trains
stations
police chase
real-time logic

Programming becomes much easier and more fun.

9.Final Thoughts

The while loop is one of the most powerful concepts in Python.

Whether you're:

searching for values
building games
creating simulations
solving real-world problems

while loops are everywhere.

The best way to master loops is:

Practice
Visualize
Build logic gradually

Because programming is not about memorizing syntax —
it’s about training your thinking process.

Reference

(https://www.geeksforgeeks.org/python/python-break-statement/)

(https://www.w3schools.com/python/ref_keyword_break.asp)

The One Concept That Powers Every Java Application

Hariharan S J — Wed, 27 May 2026 11:53:57 +0000

1.Introduction

Imagine trying to build an application like Instagram, Amazon, or a banking system using thousands of random functions and unorganized code. Sounds impossible, right?

As software applications started becoming larger and more complex, developers needed a smarter way to organize code — something that was secure, reusable, scalable, and easier to maintain.

That’s where Object-Oriented Programming (OOPs) changed everything.

OOPs is not just a programming concept in Java.
It is the foundation behind how modern software is designed.

From mobile apps to enterprise systems , Java uses OOPs to model real-world entities like:

Users
Cars
Bank Accounts
Employees
Shopping Carts

into reusable software objects.

In this blog, we’ll deeply explore:

Why OOPs is needed
The four pillars of OOPs
Internal working of classes and objects
Real-world examples
How Java uses OOPs internally

By the end of this article, you won’t just memorize OOPs concepts — you’ll actually understand why they are the backbone of Java development.

2.What is OOPs?

Object-Oriented Programming System (OOPs) is a programming approach where everything is organized around objects and classes.

Instead of writing long procedural code, OOPs allows developers to model real-world entities like:

Cars
Students
Bank Accounts
Employees

as software objects.

3.Why OOPs Concept is Needed in Java?

Imagine building a very large application like:

Instagram
Amazon
Banking Systems
Hospital Management Systems

Without proper structure, the code would become:

Messy
Difficult to manage
Hard to debug
Unsafe
Impossible to scale

This is exactly why Object-Oriented Programming (OOPs) was introduced.

OOPs helps developers organize software in a smarter and more realistic way.

The Main Problem Before OOPs

Before OOPs, many programming languages mainly followed:

Procedural Programming

In procedural programming:

Everything is written as functions
Data is shared globally
Programs become harder to maintain as size increases

Example of Procedural Problem

Imagine creating a banking application.

You may have:

deposit()
withdraw()
checkBalance()
transferMoney()

All functions directly access shared data.

As the application grows:

Bugs increase
Security issues appear
Code duplication happens
Maintenance becomes difficult

For small programs this is okay.

But for real-world applications with millions of users, this becomes a disaster.

Why OOPs Was Introduced

OOPs was introduced to solve these real software development problems.

It helps developers:

Organize code properly
Reuse existing code
Improve security
Reduce complexity
Build scalable applications
Model real-world entities

4.Understanding Class and Object

Class

A class is a blueprint or template for creating objects.

Example:

class Car {
    String brand;
    int speed;
}

Here, Car is a class.

Object

An object is an instance of a class.

Car c1 = new Car();

Here, c1 is an object of the Car class.

5.The Four Pillars of OOPs

These are the core concepts that define Object-Oriented Programming:

Encapsulation
Inheritance
Polymorphism
Abstraction

1. Encapsulation

What is Encapsulation?

Encapsulation means:

Wrapping data and methods together into a single unit.

It also means restricting direct access to sensitive data.

In Java, encapsulation is achieved using:

Private variables
Public getter and setter methods

Why Encapsulation is Important?

Imagine a bank account.

If everyone could directly access your balance variable:

balance = -100000;

the system would become unsafe.

Encapsulation protects data from unauthorized modification.

Example of Encapsulation

class Student {

    private int marks;

    public void setMarks(int m) {

        if(m >= 0 && m <= 100) {
            marks = m;
        }
    }

    public int getMarks() {
        return marks;
    }
}

2. Inheritance

What is Inheritance?

Inheritance allows one class to acquire the properties and behaviors of another class.

The existing class is called:

Parent Class
Super Class
Base Class

The new class is called:

Child Class
Sub Class
Derived Class

Why Inheritance?

Without inheritance, developers would repeatedly write the same code.

Inheritance promotes:

Code Reusability
Maintainability
Hierarchical Relationships

Example of Inheritance

class Animal {

    void eat() {
        System.out.println("Animal eats food");
    }
}

- 
class Dog extends Animal {

    void bark() {
        System.out.println("Dog barks");
    }
}

3. Polymorphism

What is Polymorphism?

Polymorphism means:

One entity behaving in multiple forms.

Example:

A person can behave differently as:

Student
Employee
Customer

Similarly, Java methods can behave differently depending on the situation.

Types of Polymorphism

Method Overloading (TBD)
Method Overriding (TBD)

4. Abstraction

What is Abstraction?

Abstraction means:

Hiding internal implementation and showing only essential features.

Example:

You drive a car using:

Steering
Brake
Accelerator

But you don’t see internal engine mechanisms.

Why Abstraction?

Without abstraction, systems become extremely complex.

Abstraction reduces complexity.

abstract class Vehicle {

    abstract void start();

    void stop() {
        System.out.println("Vehicle stopped");
    }
}

6.Final Conclusion

OOPs is not just a programming topic.

It is a software design philosophy that helps developers create clean, maintainable, reusable, and scalable applications.

To truly master Java, understanding these concepts deeply is essential:

Encapsulation
Inheritance
Polymorphism
Abstraction

Once these concepts become clear, writing advanced Java applications becomes much easier.

Java Isn’t Just a Language — It’s an Ecosystem

Hariharan S J — Tue, 26 May 2026 12:42:07 +0000

1.Introduction

Have you ever wondered how the same Java program runs perfectly on Windows, Linux, and macOS without changing a single line of code?

That’s the magic of Java Architecture.

Behind every Java application, powerful components like JVM, JDK, JRE, Bytecode, and JIT Compiler work together to make Java secure, portable, and incredibly powerful.

But most beginners use Java without actually understanding what happens internally when a Java program runs.

In this blog, we’ll break down the complete architecture of Java in a simple and beginner-friendly way. From the history of Java to understanding how bytecode works and why Java follows the famous principle:

“Write Once, Run Anywhere”

You’ll learn everything you need to build a strong foundation in Java.

2.Origin of Java

Java was developed by James Gosling and his team at Sun Microsystems in the early 1990s.

The project started in 1991.

The main members of the Java team were:

James Gosling
Mike Sheridan
Patrick Naughton

This team was later called the Green Team.

3.Why Was Java Created?

Initially, Java was developed for:

Television systems
Embedded devices
Electronic appliances

The goal was to create a language that could run on multiple devices without modification.

At that time, existing languages were platform dependent.

The Green Team wanted a language that followed:

“Write Once, Run Anywhere”

4.What is Java?

Java is a high-level, object-oriented programming language developed by Oracle Corporation.

Java is designed to be:

Simple
Secure
Portable
Platform Independent

Java Program Execution Flow

Java Source Code (.java)
        ↓
Compiler (javac)
        ↓
Bytecode (.class)
        ↓
JVM
        ↓
Machine Code
        ↓
Output

5.What is JDK?

JDK → Java Development Kit

JDK is a complete package used for developing Java applications.

It provides all the tools required to:

Write Java programs
Compile Java code
Run Java applications
Debug programs

Components of JDK

JDK contains:

JRE
Java Compiler (javac)
Debugging tools
Documentation tools
Development utilities

Formula

JDK = JRE + Development Tools

6.Why JDK is Important?

Without JDK, developers cannot create Java applications because it contains the compiler needed to convert source code into bytecode.

7.What is Bytecode?

Bytecode Definition

Bytecode is the intermediate code generated after compiling a Java program.

When we compile:

javac Hello.java

Java creates:

Hello.class

This .class file contains bytecode.

Why Bytecode is Important?

Bytecode is platform independent.

This means the same bytecode can run on:

Windows
Linux
macOS

This is the core reason behind Java’s portability.

8.What is JVM?

JVM → Java Virtual Machine

JVM is the heart of Java Architecture.

It converts bytecode into machine code and executes the program.

JVM acts as a bridge between Java applications and the operating system.

Responsibilities of JVM

Loads class files
Verifies bytecode
Executes code
Allocates memory
Performs Garbage Collection

9.What is JIT Compiler?

JIT → Just-In-Time Compiler

The JIT Compiler improves Java performance.

Instead of interpreting the same bytecode repeatedly, JIT converts frequently used bytecode into native machine code.

This makes Java programs faster.

How JIT Works?

Without JIT:

Bytecode → Interpreter → Execution

With JIT:

Bytecode → JIT Compiler → Native Machine Code → Faster Execution

Advantages of JIT Compiler

Improves performance
Reduces execution time
Optimizes frequently used code
Makes Java applications faster

10.What is JRE?

JRE → Java Runtime Environment

JRE provides the environment required to run Java applications.

It contains:

JVM
Core libraries
Supporting files

Formula

JRE = JVM + Libraries

Why JRE is Important?

If you only want to run Java applications and not develop them, JRE is enough.

11.Final Takeaway

Understanding concepts like JDK, JVM, JRE, Bytecode, and JIT Compiler is essential for every Java developer.

These concepts explain:

How Java programs execute
Why Java is platform independent
How Java manages memory
How Java achieves performance

Once you understand Java Architecture deeply, learning advanced Java concepts becomes much easier.

How a Simple Frog Story Helped Me Understand Python Loops

Hariharan S J — Tue, 26 May 2026 09:51:15 +0000

1.Introduction

Learning programming becomes easier when we connect code with real-world stories.

Instead of directly jumping into theory, I tried solving a small story-based Python problem about a frog trapped inside a well.

Even though the code is very small, it teaches some powerful beginner concepts like:

Loops
Variables
Conditions
Logical thinking

In this blog, let’s understand how this simple frog problem works step by step.

2.The Story Problem

Imagine a frog accidentally falls into a 50-feet deep well.

Now the frog tries to escape:

It climbs 2 feet upward
But slips 1.25 feet downward

This process repeats every single day.

The question is:

“How many days will the frog take to escape the well?”

3.Thinking Like a Programmer

Instead of solving this manually day by day, we can automate it using Python.

We need:

A variable to store the remaining depth
A loop because the process repeats
A counter to track the number of days

Python Code

feet = 50
up = 2
down = 1.25
day = 0

while feet > 0:
    feet = feet - up + down
    day = day + 1

print(day)

4.Step-by-Step Explanation

Storing the Initial Values

feet = 50

This represents the total depth of the well.

up = 2
down = 1.25

up → how much the frog climbs
down → how much the frog slips

Counting the Days

day = 0

Initially, no days have passed.

Understanding the while Loop

while feet > 0:

This loop keeps running until the frog escapes the well.

As long as the remaining depth is greater than 0, the loop continues.

The Main Logic

feet = feet - up + down

Here’s what happens every day:

Frog climbs 2 feet
Frog slips 1.25 feet

So the net movement becomes:

2 - 1.25 = 0.75 feet

The frog effectively climbs 0.75 feet per day.

Increasing the Day Count

day = day + 1

Every loop execution represents one full day.

Final Output

The frog escapes the well in 67 days.

Concepts Learned From This Problem

This simple program teaches:

Variables
while loops
Arithmetic operations
Problem-solving
Logic building

5.Why Story-Based Problems Are Great

Story-based coding problems are excellent for beginners because they make programming feel practical and interesting.

Instead of memorizing syntax, you start understanding:

“Why are we using this logic?”

That is where real programming learning begins.

6.Final Takeaway

Even a tiny Python program can teach powerful programming concepts.

The frog escape problem may look simple, but it helps beginners understand how loops work in real scenarios.

Sometimes the best way to improve coding skills is by solving small and fun logical problems consistently

The Backbone of Python: Conditions and Loops

Hariharan S J — Sun, 24 May 2026 11:52:41 +0000

1.Python Conditional Statements and Looping Statements

Python is one of the most popular programming languages because of its simple syntax and powerful features. Two of the most fundamental concepts in Python are Conditional Statements and Looping Statements. These concepts help programmers build logical, interactive, and efficient applications.

Conditional statements help Python make decisions, while looping statements help Python repeat tasks multiple times without writing the same code again and again.

Understanding these concepts is essential for every beginner because they form the foundation of real-world programming.

2.What are Conditional Statements in Python?

Conditional statements are used to execute specific blocks of code based on conditions.

In simple words:

Conditional statements help Python make decisions.

For example:

if the password is correct → Login successful
If marks are above 90 → Grade A
If age is above 18 → Eligible to vote

Python uses conditional statements to perform these decision-making operations.

3.Why Conditional Statements are Used in Python?

Conditional statements are used in Python to make decisions based on conditions.

In simple words:

Conditional statements help Python decide which code should execute and which code should not execute.

They allow programs to behave differently in different situations.

4.Why Are Conditional Statements Important?

Without conditional statements:

Programs cannot make decisions
Every line of code would execute in the same order
Applications would not become interactive or smart

Conditional statements make programs:

Intelligent
Dynamic
Interactive
Flexible

5.Types of Conditional Statements

Python mainly provides four types of conditional statements:

if statement
if-else statement
if-elif-else statement
Nested if statement

1. if Statement

The if statement executes code only when the condition becomes true.

Syntax

if condition:
    statement

Example

age = 20

if age >= 18:
    print("Eligible to vote")

Output

Eligible to vote

Explanation

Python checks whether the condition is true.

If true → Code executes
If false → Code is skipped

2. if-else Statement

The if-else statement is used when there are two possible outcomes.

Example

number = 7

if number % 2 == 0:
    print("Even Number")
else:
    print("Odd Number")

Output

Odd Number

Explanation

If the condition is true → if block executes
Otherwise → else block executes

3. if-elif-else Statement

When multiple conditions need to be checked, Python uses elif.

Example

marks = 85

if marks >= 90:
    print("Grade A")
elif marks >= 75:
    print("Grade B")
elif marks >= 50:
    print("Grade C")
else:
    print("Fail")

Output

Grade B

Explanation

Python checks conditions one by one from top to bottom.

Once a condition becomes true, the remaining conditions are skipped.

4. Nested if Statement

An if statement inside another if statement is called a nested if.

Example

age = 20
has_id = True

if age >= 18:
    if has_id:
        print("Entry Allowed")

Output

Entry Allowed

6.What are Looping Statements in Python?

Looping statements are used to execute a block of code repeatedly.

In simple words:

Loops help Python repeat tasks automatically.

Instead of writing the same code multiple times, loops perform repetition efficiently.

7.Why Looping Statements are Used in Python?

Looping statements are used in Python to execute a block of code repeatedly without writing the same code again and again.

In simple words:

Loops help Python repeat tasks automatically.

Without loops, programmers would need to write repetitive code manually, which makes programs lengthy and inefficient.

8.Real-Life Example

Imagine you want to print "Hello" 5 times.

Without loops

print("Hello")
print("Hello")
print("Hello")
print("Hello")
print("Hello")

Using loops

count = 1

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

9.Types of Looping Statements in Python

Python mainly provides two looping statements:

for loop (TBD)
while loop

while Loop

The while loop executes as long as the condition remains true.

Syntax

while condition:
    statement

Example

count = 1

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

Output

Explanation

The loop continues until the condition becomes false.

What Does end=" " Mean?

Normally, print() moves to the next line automatically.

But:

end=" "

tells Python:

Do not move to next line
Print a space after the output

That is why all numbers appear in a single line

count = 1

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

Output

1 2 3 4 5

10.Real-World Importance of Conditional and Looping Statements

These concepts are used everywhere in programming:

Login authentication systems
E-commerce websites
Banking applications
Chat applications
Games
Artificial Intelligence systems

They are the building blocks of programming logic.

11.Final Takeaway

Conditional statements and looping statements are two of the most important concepts in Python programming.

Conditional statements help programs make decisions.
Looping statements help programs repeat tasks efficiently.

By mastering:

if, else, and elif
for and while loops
Logical and comparison operators

you build a strong foundation for advanced Python concepts and real-world software development.

From Props to Global State: Understanding Redux

Hariharan S J — Thu, 21 May 2026 11:34:35 +0000

1.Introduction

If you’ve worked on a React project before, you’ve probably faced this frustrating situation:

A parent component has some data…
A child component needs that data…
Then another child needs it too…

So what do we do?

We keep passing props from one component to another.

Parent → Child → Grandchild → Great Grandchild

At first, this seems manageable.

But as your application grows, your component structure slowly turns into a nightmare of endless prop passing.

This problem is called:

Prop Drilling

And this is exactly where Redux enters the picture.

Redux is one of the most powerful state management libraries used in React applications. It helps developers manage shared data in a centralized and predictable way without passing props through multiple layers of components.

Instead of scattering state across different parts of your application, Redux gives you a single global store where your application data lives.

This makes your applications:

Easier to scale
Easier to debug
Easier to maintain
More predictable

From authentication systems and shopping carts to large enterprise dashboards, Redux is widely used in modern React applications where managing complex state becomes difficult.

In this blog, we’ll break down Redux in the simplest way possible, understand how it works internally, and explore concepts like stores, actions, reducers, dispatching, and global state with practical examples.

2.What is Redux in React?

Redux is a popular state management library used in React applications to manage and share data across multiple components in a predictable way.

In simple terms, Redux acts like a central storage system for your application’s data.

Instead of passing data manually from one component to another using props, Redux allows all components to access shared data directly from a single global store.

3.Why Do We Need Redux?

In small React applications, managing state using useState and passing props between components works perfectly fine.

But as applications grow larger, problems start appearing:

Too many props being passed
Complex state management
Difficult data sharing
Hard-to-maintain component structure

This problem is called:

Prop Drilling

Redux solves this problem by creating one centralized store where all shared data is managed.

4.Understanding Redux with a Simple Analogy

Think of Redux like a bank locker system.

Redux Store = Central Locker
Components = Customers
Actions = Requests
Reducers = Bank Employees

How it works:

A component requests a change
Redux processes the request
Store updates the data
All connected components receive updated data automatically

5.How to Install Redux in React

When building small React applications, Hooks like useState and useContext are often enough for managing state. But as applications grow larger and more complex, managing shared data across multiple components becomes difficult.

This is where Redux comes into the picture.

Redux is a powerful state management library that helps developers manage global application state in a centralized and predictable way.

In modern React applications, developers mainly use:

Redux Toolkit (RTK)

because it simplifies Redux setup and reduces unnecessary boilerplate code.

6.Installing Redux in React

To use Redux in a React application, we mainly need two packages:

@reduxjs/toolkit
react-redux

Install them using npm:

npm install @reduxjs/toolkit react-redux

7.Understanding the Packages

Package	Purpose
`@reduxjs/toolkit`	Simplifies Redux setup
`react-redux`	Connects Redux with React

7.Core Concepts of Redux

Redux mainly works with four important concepts:

Concept	Purpose
Store	Central place that stores application state
Action	Object that describes what happened
Reducer	Function that updates state
Dispatch	Sends actions to reducers

1. Store

The store is the central place where all application data is stored.

Example:

const store = createStore(reducer);

Think of it like the brain of Redux.

All shared state lives inside the store.

2. Actions

Actions describe what should happen.

Example:

{
  type: "INCREMENT"
}

An action is simply a JavaScript object.

It tells Redux:

“Hey, something happened. Update the state.”

3. Reducers

Reducers decide how the state should change.

Example

function counterReducer(state = 0, action) {
  switch(action.type) {
    case "INCREMENT":
      return state + 1;

    default:
      return state;
  }
}

Reducer:

Receives current state
Receives action
Returns updated state

4. Dispatch

Dispatch sends actions to Redux.

Example:

dispatch({ type: "INCREMENT" });

This tells Redux to update the store.

8.How Redux Flow Works

Redux follows a one-way data flow.

Component
   ↓
Dispatch Action
   ↓
Reducer
   ↓
Store Updates
   ↓
UI Re-renders

This predictable flow makes debugging easier.

Example: Counter App Using Redux

const initialState = {
  count: 0
};

function reducer(state = initialState, action) {
  switch(action.type) {
    case "INCREMENT":
      return {
        ...state,
        count: state.count + 1
      };

    default:
      return state;
  }
}

Dispatching action:

dispatch({ type: "INCREMENT" });

Redux updates the store automatically.

9.What is Global State?

Global state means data that multiple components need access to.

Examples:

Authentication
Shopping cart
Theme mode
User profile
Notifications

Redux helps manage this shared data efficiently.

10.Redux vs useState

`useState`	Redux
Local component state	Global application state
Best for small apps	Best for large apps
Simple state handling	Complex state management
Data shared using props	Data shared through store

11.Real-World Use Cases of Redux

E-commerce shopping carts
Authentication systems
Dashboard applications
Social media apps
Real-time notifications
Theme management
Large-scale enterprise applications

12.Final Takeaway

Redux is a powerful state management library that helps React applications manage shared data in a centralized and predictable way.

While React Hooks like useState are perfect for local component state, Redux becomes extremely useful when applications grow larger and multiple components need access to the same data.

Understanding Redux is an important step toward building scalable React applications because it teaches developers how to manage complex application state efficiently and maintain a clean architecture.

The Hidden Power of useRef in React

Hariharan S J — Wed, 20 May 2026 10:45:49 +0000

1.Introduction

When learning React Hooks, most developers immediately focus on hooks like useState and useEffect. While these Hooks are extremely important, another powerful Hook that often gets overlooked is useRef.

At first glance, useRef may seem confusing because unlike useState, updating a useRef value does not re-render the component. But once you understand how it works, you’ll realize that useRef is one of the most useful Hooks for handling DOM interactions, storing mutable values, and improving performance in React applications.

The useRef Hook allows developers to:

Access DOM elements directly
Focus input fields
Store values between renders
Manage timers and intervals
Avoid unnecessary re-renders

In modern React applications, useRef is commonly used behind the scenes for things like form handling, video controls, scroll tracking, and performance optimization.

In this blog, we’ll explore what useRef actually is, how it works i
nternally, and where it is used in real-world React projects with practical examples and beginner-friendly explanations.

2.What is useRef in React?

useRef is a React Hook that lets you reference a value that’s not needed for rendering.

In simple terms, useRef gives you a way to:

Directly access DOM elements
Store mutable values
Preserve values between renders

Unlike useState, updating a useRef value does not re-render the component.

3.Why Do We Need useRef?

Sometimes in React, we need to:

Focus an input field
Access a button directly
Store timer IDs
Remember previous values
Work with DOM elements

This is where useRef becomes useful.

Think of useRef as a special storage box that React remembers between renders.

4.Syntax of useRef

const ref = useRef(initialValue);

Example:

const inputRef = useRef(null);

Here:

inputRef → Reference object
null → Initial value

5.Understanding How useRef Works

useRef returns an object like this:

{
  current: value
}

Example:

const myRef = useRef(0);

console.log(myRef);

Output:

{
  current: 0
}

The actual value is stored inside:

myRef.current

6.Accessing DOM Elements with useRef

One of the most common use cases.

Example:

import { useRef } from "react";

function App() {
  const inputRef = useRef();

  const focusInput = () => {
    inputRef.current.focus();
  };

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

      <button onClick={focusInput}>
        Focus Input
      </button>
    </div>
  );
}

How this works:

inputRef is connected to the input element
React stores the DOM element inside inputRef.current
When button is clicked:

inputRef.current.focus()

Input field gets focused

7.useRef vs useState

This is one of the most important concepts.

useState	useRef
Causes re-render	Does NOT cause re-render
Used for UI updates	Used for storing mutable values
Updates visible data	Stores values silently

8.Example Difference

Using useState:

const [count, setCount] = useState(0);

Changing state updates the UI.

Using useRef:

const countRef = useRef(0);

Changing:

countRef.current++;

will NOT re-render the component.

9.Storing Previous Values with useRef

useRef is useful for remembering old values.

Example:

import { useEffect, useRef, useState } from "react";

function App() {
  const [count, setCount] = useState(0);
  const previousCount = useRef();

  useEffect(() => {
    previousCount.current = count;
  }, [count]);

  return (
    <div>
      <h1>Current: {count}</h1>
      <h2>Previous: {previousCount.current}</h2>

      <button onClick={() => setCount(count + 1)}>
        Increase
      </button>
    </div>
  );
}

Here:

count stores current value
previousCount.current stores old value

10.Real-World Use Cases of useRef

You’ll commonly use useRef for:

Focusing input fields
Accessing DOM elements
Managing timers
Storing previous values
Preventing unnecessary re-renders
Video/audio controls
Scroll position tracking

11.Simple Analogy for Understanding useRef

Think of useRef like a hidden notebook inside a component.

React remembers the notebook between renders, but changing the notebook does not update the screen.

Example:

useState  → updates UI
useRef    → stores values silently

12.Final Takeaway

useRef is a powerful Hook that allows React developers to directly access DOM elements and store mutable values without causing unnecessary re-renders.

While useState is used for updating the UI, useRef is mainly used for storing values behind the scenes and interacting with the DOM efficiently.

Understanding when to use useRef instead of useState is an important step toward becoming a better React developer because it helps improve both performance and code organization.

Understanding React’s Core Hooks: useState & useEffect

Hariharan S J — Tue, 19 May 2026 11:30:43 +0000

1.Introduction

React has become one of the most popular JavaScript libraries for building modern user interfaces. But what truly changed the way developers write React applications was the introduction of Hooks in React 16.8.

Before Hooks, developers mainly relied on class components to manage state, lifecycle methods, and side effects. This often made applications harder to understand and maintain. React Hooks solved this problem by allowing developers to use state and other React features directly inside functional components.

Hooks make React code:

Cleaner
More readable
Easier to reuse
Simpler to maintain

Today, almost every modern React application heavily depends on Hooks for handling state management, API calls, performance optimization, and reusable logic.

From simple hooks like useState and useEffect to advanced hooks like useReducer and useMemo, each hook solves a specific problem and helps developers build better applications more efficiently.

In this blog, we’ll explore the most important React Hooks every developer should know, understand how they work, and learn where they are commonly used in real-world projects.

2.What is useState in React?

useState is one of the most important and commonly used Hooks in React. It allows functional components to store, manage, and update data that can change over time.

In simple terms, useState helps React “remember” values and update the UI whenever those values change.

For example, imagine a counter app:

Count starts at 0
When you click a button, the value increases
The UI updates automatically

Without useState, React would not know when to update the screen.

Why Do We Need useState?

Normally, variables in JavaScript do not persist between renders.

For example:

let count = 0;

function increase() {
  count++;
  console.log(count);
}

Even though count changes, React will not automatically update the UI because normal variables are not reactive.

This is where useState comes in.

useState tells React:

“This value can change, and whenever it changes, update the UI.”

Syntax of useState

const [state, setState] = useState(initialValue);

Let’s break this down:

const [count, setCount] = useState(0);

Here:

count → Current state value
setCount → Function used to update the state
0 → Initial value of the state

Think of it like this:

count → current value
setCount → updates value
useState(0) → starting value

How useState Works

When state changes, React automatically re-renders the component.

Example:

import { useState } from "react";

function Counter() {
  const [count, setCount] = useState(0);

  return (
    <div>
      <h1>{count}</h1>

      <button onClick={() => setCount(count + 1)}>
        Increase
      </button>
    </div>
  );
}

How this works:

Initial value starts at 0
User clicks the button
setCount(count + 1) runs
React updates the state
Component re-renders
UI updates automatically

So if count becomes 1, React updates the screen instantly.

Understanding State in Simple Words

You can think of state like a memory box inside a component.

Example:

Counter Component
┌───────────┐
│ count = 0 │
└───────────┘

When the button is clicked:

Counter Component
┌───────────┐
│ count = 1 │
└───────────┘

React notices the change and updates the UI.

Updating State

You update state using the setter function.

Example:

setCount(10);

This changes the value to 10.

You can also update based on the previous value:

setCount(prev => prev + 1);

This is called a functional update.

This approach is useful when the new state depends on the old state.

Example:

setCount(prev => prev + 1);
setCount(prev => prev + 1);

This ensures React updates correctly.

Real-World Use Cases of useState

Counter apps
Form handling
Toggle buttons
Dark/light theme
Search input values
Shopping cart quantity
Modal open/close

3.What is useEffect in React?

useEffect is one of the most powerful Hooks in React. It is used to perform side effects inside functional components.

In simple terms, useEffect allows React components to do something after rendering.

This could include:

Fetching data from an API
Updating the document title
Setting timers
Adding event listeners
Accessing browser APIs
Cleaning up resources

Before Hooks existed, these operations were handled using lifecycle methods in class components like componentDidMount and componentDidUpdate.

But with useEffect, React made this process much simpler and cleaner.

What is a Side Effect?

A side effect is anything that affects something outside the component itself.

Examples:

Calling an API
Changing the webpage title
Starting a timer
Listening to keyboard or mouse events
Updating local storage

These operations happen outside the normal rendering process.

That’s why React provides useEffect.

Syntax of useEffect

useEffect(() => {
  // side effect code
}, []);

Let’s break this down:

useEffect(() => {
  console.log("Component rendered");
}, []);

Here:

useEffect() → React Hook
First argument → Function containing side effect code
Second argument → Dependency array

How useEffect Works

React first renders the component.

After rendering is completed, React runs the code inside useEffect.

Think of it like this:

1. Component renders
2. UI appears on screen
3. useEffect runs

This is why useEffect is called a side-effect Hook.

Example: Updating the Document Title

import { useState, useEffect } from "react";

function Counter() {
  const [count, setCount] = useState(0);

  useEffect(() => {
    document.title = `Count: ${count}`;
  });

  return (
    <button onClick={() => setCount(count + 1)}>
      {count}
    </button>
  );
}

What happens here?

Component renders
useEffect runs
Browser tab title updates
Every time count changes, effect runs again

Understanding the Dependency Array

The dependency array controls when the effect should run.

This is one of the most important concepts in useEffect.

1. No Dependency Array

useEffect(() => {
  console.log("Runs after every render");
});

Effect runs:

After first render
After every re-render

2. Empty Dependency Array

useEffect(() => {
  console.log("Runs only once");
}, []);

Effect runs:

Only once after initial render

This behaves similar to:

componentDidMount()

Common use cases:

API calls
Initial setup
Fetching data

3. Dependency Array with Values

useEffect(() => {
  console.log("Runs when count changes");
}, [count]);

Effect runs:

Initial render
Whenever count changes

React watches the dependency value.

If the value changes, React reruns the effect.

Fetching Data with useEffect

One of the most common use cases.

Example:

import { useEffect, useState } from "react";

function Users() {
  const [users, setUsers] = useState([]);

  useEffect(() => {
    fetch("https://jsonplaceholder.typicode.com/users")
      .then(res => res.json())
      .then(data => setUsers(data));
  }, []);

  return (
    <div>
      {users.map(user => (
        <p key={user.id}>{user.name}</p>
      ))}
    </div>
  );
}

What happens here?

Component loads
useEffect runs once
API request happens
State updates
UI re-renders with data

Cleanup Function in useEffect

Sometimes effects create resources that need cleanup.

Examples:

Timers
Event listeners
Subscriptions

React provides a cleanup function for this.

Syntax:

useEffect(() => {
  // setup code

  return () => {
    // cleanup code
  };
}, []);

Real-World Use Cases of useEffect

You’ll use useEffect for:

API calls
Authentication checks
Timers and intervals
Event listeners
Local storage
Updating document title
Real-time data fetching
Socket connections

4.Final Takeaway

React Hooks completely changed the way developers build React applications. Among all Hooks, useState and useEffect are the foundation of modern React development.

useState helps components store and manage dynamic data, while useEffect allows components to interact with the outside world through side effects like API calls, timers, and event listeners.

Together, these two Hooks make React applications:

More dynamic
More interactive
Easier to maintain
Cleaner to write