DEV Community: Madhavan G

What Is OOP in Java? Classes, Objects, and the Four Pillars.

Madhavan G — Thu, 16 Jul 2026 15:14:56 +0000

What is OOPs?

OOPs stands for Object-Oriented Programming.

It is a programming style where we create programs using objects. These objects represent real-world things like a student, a car, a mobile phone, or a bank account.

Instead of writing one huge program with everything mixed together, OOP helps us organize our code into small, manageable pieces.

In Java, everything is centered around classes and objects, mimicking real-world entities to make code modular, reusable, and easy to maintain.

Think of it like organizing your room.

Clothes go into one cupboard.
Books go on one shelf.
Shoes stay in one place.

Everything has its own place.

OOP does the same thing for our code.

Why Do We Need OOP?

Imagine you are building a School Management System.

You need to store information about hundreds of students.

Without OOP, your code might look like this:

String student1Name = "Rahul";
int student1Age = 20;

String student2Name = "Anjali";
int student2Age = 21;

String student3Name = "John";
int student3Age = 19;

Now imagine there are 1,000 students.

Your program becomes huge, repetitive, and difficult to manage.

Now let's solve the same problem using OOP.

Student s1 = new Student();
Student s2 = new Student();
Student s3 = new Student();

That's it!

We create one blueprint called Student, and then we create as many students as we need.

This makes the code:

Cleaner
Easier to understand
Easier to update
Easier to reuse

What is a Class?

A class is simply a blueprint or template.

Let's use a real-life example.

Suppose an architect designs a house.

The drawing is called a blueprint.

The blueprint tells us:

Where the doors are
Where the windows are
Where the kitchen is

But can you live inside the blueprint?

No!

It is only a design.

Similarly, in Java:

A class is only a blueprint.

Example:

class Student {

    String name;
    int age;

}

This class only describes what a student looks like.

It doesn't create a real student yet.

What is an Object?

An object is the real thing created from a class.

Using our house example:

Blueprint → Class
Real House → Object

In Java:

Student s1 = new Student();

Now a real student object has been created.

Let's give it some data.

s1.name = "Rahul";
s1.age = 20;

Now this object represents a real student.

Another object can store different data.

Student s2 = new Student();

s2.name = "Anjali";
s2.age = 22;

Both objects are created from the same class, but they hold different information.

Properties and Methods

Every object has two things:

1. Properties (Data)

Properties describe the object.

For a Student:

Name
Age
Roll Number

For a Car:

Brand
Color
Speed

2. Methods (Actions)

Methods describe what an object can do.

For a Student:

Study
Attend Class
Write Exam

For a Car:

Start
Stop
Drive

Example:

class Student {

    String name;

    void study() {
        System.out.println(name + " is studying.");
    }

}

Using the object:

Student s1 = new Student();

s1.name = "Rahul";

s1.study();

Output:

Rahul is studying.

Example

Let's create a simple Car class.

class Car {

    String brand;
    String color;

    void start() {
        System.out.println("Car Started");
    }

    void stop() {
        System.out.println("Car Stopped");
    }

}

Now create an object.

public class Main {

    public static void main(String[] args) {

        Car car1 = new Car();

        car1.brand = "Toyota";
        car1.color = "White";

        car1.start();
        car1.stop();

    }

}

Output:

Why Is OOP So Powerful?

Suppose a car company manufactures 10,000 cars.

Do they design every car from scratch?

No.

They create one design and use it to build thousands of cars.

OOP works the same way.

One class.

Many objects.

Example:

Car car1 = new Car();
Car car2 = new Car();
Car car3 = new Car();

Each object can have different values.

Car 1
Brand : BMW
Color : Black

Car 2
Brand : Audi
Color : White

Car 3
Brand : Toyota
Color : Red

The Four Pillars of Object-Oriented Programming (OOPs)

1. Encapsulation – Protecting Your Data

What is Encapsulation?

Encapsulation means wrapping data (variables) and methods (functions) together into a single unit (class) while controlling how the data is accessed.

In simple words, don't allow anyone to change your data directly. Instead, provide controlled methods to access or modify it.

Imagine you have a bank account.

You cannot directly go into the bank's database and change your account balance.

Instead, you use services like:

Deposit money
Withdraw money
Check balance

The bank controls how your balance changes. This is exactly how encapsulation works.

Real-Life Example

Think about an ATM.

You can:

Insert your card
Enter your PIN
Withdraw money
Check your balance

But you cannot directly open the ATM and change the amount of money inside.

The ATM hides its internal data and only allows certain operations.

This is encapsulation.

What Are Getters and Setters in Encapsulation?

When we make a variable private, it cannot be accessed directly from outside the class.

So how do we read or update its value?

This is where getters and setters come in.

A Getter is a method that returns (gets) the value of a private variable.
A Setter is a method that updates (sets) the value of a private variable.

Think of them as controlled doors to your data.

Instead of allowing anyone to access your data directly, you decide how people can read or modify it.

Why Do We Use Getters and Setters?

Imagine you're creating a Student class.

You don't want someone to accidentally assign an invalid age like -10 or 500.

Without getters and setters, someone could write:

student.age = -10;

This doesn't make sense because a person's age cannot be negative.

Instead, we make the variable private and provide a setter method that checks whether the value is valid before saving it.

Example Without Encapsulation

class Student {

    public int age;

}

Student student = new Student();

student.age = -10;

System.out.println(student.age);

Output:

-10

The program accepts an invalid age because there is no validation.

Example With Encapsulation

class Student {

    private int age;

    public void setAge(int age) {

        if (age > 0) {
            this.age = age;
        } else {
            System.out.println("Invalid age");
        }

    }

    public int getAge() {
        return age;
    }

}

Now use the class.

Student student = new Student();

student.setAge(20);

System.out.println(student.getAge());

Output:

Now try this:

student.setAge(-10);

Output:

Invalid age

The invalid value is rejected because the setter method checks the data before storing it.

Understanding the Getter

public int getAge() {
    return age;
}

Let's understand this line by line.

public → Anyone can call this method.
int → The method returns an integer.
getAge() → Method name. By convention, getter methods start with get.
return age; → Sends the value of the private variable back to the caller.

When you write:

System.out.println(student.getAge());

The getter returns the value stored in age, which is then printed.

Understanding the Setter

public void setAge(int age) {
    this.age = age;
}

Let's break it down.

public → Anyone can call this method.
void → The method doesn't return any value.
setAge(int age) → Accepts a new age as a parameter.
this.age = age; → Stores the given value in the object's age variable.

Notice that both the parameter and the instance variable are named age.

The keyword this refers to the current object's variable.

So:

this.age = age;

means:

"Store the parameter age into this object's age variable."

Without this, Java wouldn't know which age you mean because both have the same name.

Real-Life Analogy

Think of a school office.

The student's records are stored in a secure room.

Students cannot enter the room and edit their records directly.

Instead:

If they want to see their details, they ask the office staff. (Getter)
If they want to update their address or phone number, they submit a request to the office staff. (Setter)

The office staff checks whether the information is valid before updating the records.

This is exactly how getters and setters work in Java.

Benefits of Using Getters and Setters

Using getters and setters provides several advantages:

Protects important data from direct access.
Allows validation before updating values.
Prevents invalid data from entering the program.
Makes the code easier to maintain.
Gives you full control over how data is accessed and modified.

That's why getters and setters are considered a fundamental part of Encapsulation in Java.

Why is Encapsulation Important?

Without encapsulation:

Anyone can modify your data.
Invalid values can enter your program.
Bugs become more common.

With encapsulation:

Data stays safe.
Validation becomes easier.
The program becomes more secure.
Future changes become simpler because all updates go through methods.

2. Inheritance – Reusing Existing Code

What is Inheritance?

Inheritance allows one class to use the properties and methods of another class.

Instead of writing the same code again and again, we reuse it.

This saves both time and effort.

Real-Life Example

Imagine a family.

A child inherits certain characteristics from their parents.

For example:

Eye color
Hair color
Height

Similarly, in Java, one class can inherit features from another class.

Another Example

Suppose we have an Animal class.

Every animal can:

Eat
Sleep
Walk

Instead of writing these methods separately for Dog, Cat, Cow, and Horse, we create one Animal class.

Animal
   |
   +-- Dog
   |
   +-- Cat
   |
   +-- Cow

Now every animal automatically gets these common features.

Java Example

class Animal {

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

}

class Dog extends Animal {

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

}

Using the object:

Dog dog = new Dog();

dog.eat();

dog.bark();

Output:

Animal is eating
Dog is barking

Notice that the Dog class didn't define the eat() method.

It inherited it from the Animal class.

Why is Inheritance Important?

Imagine writing software for a zoo.

There may be hundreds of animal types.

Instead of rewriting common code for every animal, inheritance lets us write it once and reuse it everywhere.

Benefits include:

Less duplicate code
Easier maintenance
Faster development
Better organization

3. Polymorphism – One Method, Many Behaviors

What is Polymorphism?

The word Polymorphism comes from two Greek words:

Poly = Many
Morphism = Forms

Together, it means many forms.

In java,the same method name can behave differently depending on the object that uses it.

In Java a concept that allows a single action, method, or object to take on multiple formsis called polymorphism.

Real-Life Example

Imagine a person saying:

"I am speaking."

The action is the same—speaking—but the language can be different.

English
Tamil
Hindi
French

The action remains the same, but the behavior changes.

This is polymorphism.

Animal Example

Every animal makes a sound.

But every animal sounds different.

Dog → Bark

Cat → Meow

Cow → Moo

The method name can be sound(), but each class provides its own implementation.

Java Example

class Animal {

    void sound() {
        System.out.println("Animal makes a sound");
    }

}

class Dog extends Animal {

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

}

class Cat extends Animal {

    void sound() {
        System.out.println("Cat meows");
    }

}

Using the objects:

Dog dog = new Dog();
Cat cat = new Cat();

dog.sound();

cat.sound();

Output:

Dog barks

Cat meows

The method name is the same, but the output changes depending on the object.

Types of Polymorphism in Java

In Java, polymorphism is mainly divided into two types:

Compile-time Polymorphism (Method Overloading)
Run-time Polymorphism (Method Overriding)

Let's understand each one with simple examples.

1. Compile-time Polymorphism (Method Overloading)

What is Compile-time Polymorphism?

Compile-time polymorphism happens when multiple methods have the same name but different parameter lists.

The Java compiler decides which method to call while compiling the program, which is why it is called compile-time polymorphism.

This is also known as Method Overloading.

Real-Life Example

Think about a calculator.

The calculator has an Add button.

You can use it to add:

Two numbers
Three numbers
Decimal numbers

The action is still Add, but it works differently depending on the inputs.

This is exactly how method overloading works.

Java Example

class Calculator {

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

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

    double add(double a, double b) {
        return a + b;
    }

}

Using the methods:

Calculator calc = new Calculator();

System.out.println(calc.add(10, 20));

System.out.println(calc.add(10, 20, 30));

System.out.println(calc.add(10.5, 20.5));

Output:

30
60
31.0

Notice that all three methods have the same name (add), but they accept different parameters.

The compiler decides which method to call based on the arguments you provide.

That's why this is called Compile-time Polymorphism.

Rules for Method Overloading

To overload a method:

The method name must be the same.
The parameter list must be different (different number or types of parameters).
Changing only the return type is not enough.

For example, this is not allowed:

int add(int a, int b) { }

double add(int a, int b) { }

These methods have the same name and the same parameters, so Java will report an error.

2. Run-time Polymorphism (Method Overriding)

What is Run-time Polymorphism?

Run-time polymorphism happens when a child class provides its own implementation of a method that already exists in the parent class.

The decision about which method to execute is made while the program is running, so it is called run-time polymorphism.

This is also known as Method Overriding.

Real-Life Example

Every animal makes a sound.

But the sound is different for each animal.

Dog → Bark
Cat → Meow
Cow → Moo

The action is the same (sound()), but each animal performs it differently.

This is method overriding.

Java Example

class Animal {

    void sound() {
        System.out.println("Animal makes a 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");
    }

}

Now let's create the objects.

Animal animal;

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

animal = new Cat();
animal.sound();

Output:

Dog barks
Cat meows

Notice that the variable type is Animal, but the method that runs depends on the actual object (Dog or Cat).

Java decides this at runtime, which is why it is called Run-time Polymorphism.

Compile-time vs Run-time Polymorphism

Feature	Compile-time Polymorphism	Run-time Polymorphism
Also Known As	Method Overloading	Method Overriding
Decision Made	During compilation	During program execution
Requires Inheritance	No	Yes
Method Name	Same	Same
Parameters	Must be different	Must be the same
Example	`add(int, int)` and `add(int, int, int)`	`Animal.sound()` overridden by `Dog.sound()`

Easy Trick to Remember

A simple way to remember the difference is:

Method Overloading = Same class + Different parameters

Method Overriding = Parent class + Child class + Same method

Why is Polymorphism Important?

Polymorphism makes programs:

Flexible
Easy to extend
Easy to maintain.

4. Abstraction – Hiding Complexity

What is Abstraction?

Abstraction means showing only the important features while hiding unnecessary implementation details.

Users don't need to know how everything works internally.

They only need to know how to use it.

Real-Life Example 1 – Driving a Car

When you drive a car, you use:

Steering wheel
Accelerator
Brake
Gear

But do you know exactly how the engine, fuel injection system, and transmission work?

Probably not.

You don't need to.

The complex internal details are hidden.

This is abstraction.

Real-Life Example 2 – Mobile Phone

You press the camera button.

The phone automatically:

Opens the camera
Focuses the lens
Adjusts brightness
Captures the image
Saves it to storage

You don't see these internal steps.

You only use the feature.

That's abstraction.

Java Example

abstract class Animal {

    abstract void sound();

}

class Dog extends Animal {

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

}

The Animal class says every animal must have a sound() method, but it doesn't specify how. Each subclass provides its own implementation.

Why is Abstraction Important?

Without abstraction, users would need to understand every internal detail before using software.

With abstraction:

Programs become easier to use.
Complex code is hidden.
Developers can change internal implementation without affecting users.
Applications become cleaner and more maintainable.

Comparing the Four Pillars

Pillar	Simple Meaning	Real-Life Example
Encapsulation	Protect your data and control access	ATM or Bank Account
Inheritance	Reuse code from another class	Child inheriting traits from parents
Polymorphism	One method behaves differently	Different animals making different sounds
Abstraction	Hide complexity and show only what's needed	Driving a car or using a smartphone

Quick Summary

Concept	Meaning
OOP	Programming using objects
Class	Blueprint or template
Object	Real instance created from a class
Properties	Data about an object
Methods	Actions performed by an object
Encapsulation	Protect data
Inheritance	Reuse existing code
Polymorphism	Same method, different behavior
Abstraction	Hide internal complexity

Understanding Constructors in Java: Why We Need Them and How They Solve Object Creation Problems.

Madhavan G — Sat, 11 Jul 2026 08:02:21 +0000

This is the program we worked in the last blog

Program Without a Constructor

public class Building {

    static int age = 10;
    static String name = "Payilagam";

    String studName1 = "Mohan";
    int studAge1 = 22;

    String studName2 = "Deva";
    int studAge2 = 23;

    String studName3 = "Madhavan";
    int studAge3 = 24;

    public static void main(String[] args) {

        Building student1 = new Building();
        Building student2 = new Building();
        Building student3 = new Building();

        System.out.println(Building.name);
        System.out.println(Building.age);

        System.out.println(student1.studName1 + " " + student1.studAge1);
        System.out.println(student1.studName2 + " " + student1.studAge2);
        System.out.println(student1.studName3 + " " + student1.studAge3);
    }
}

What Is the Problem with This Program?

At first glance, the program seems to work correctly. It prints:

Payilagam
10
Mohan 22
Deva 23
Madhavan 24

However, if we carefully examine the class, we can identify several design problems.

Problem 1: One Object Contains Data for Multiple Students

Notice these instance variables:

String studName1 = "Mohan";
int studAge1 = 22;

String studName2 = "Deva";
int studAge2 = 23;

String studName3 = "Madhavan";
int studAge3 = 24;

Instead of representing one student, a single Building object stores the details of three different students.

This defeats the purpose of object-oriented programming.

Ideally,

student1 should represent only Mohan.
student2 should represent only Deva.
student3 should represent only Madhavan.

Instead, every object contains all three students.

Problem 2: Every Object Stores the Same Data

Consider these statements:

Building student1 = new Building();
Building student2 = new Building();
Building student3 = new Building();

You might expect each object to have different information.

But all three objects actually contain exactly the same values.

For example,

student1 contains

studName1 = Mohan
studName2 = Deva
studName3 = Madhavan

Similarly,

student2 also contains

studName1 = Mohan
studName2 = Deva
studName3 = Madhavan

And the same is true for student3.

Creating multiple objects serves no purpose because every object is identical.

Problem 3: Not Scalable

Imagine storing details for 100 students.

You would have to write

String studName1;
String studName2;
String studName3;
...
String studName100;

and

int studAge1;
int studAge2;
int studAge3;
...
int studAge100;

This results in hundreds of variables, making the program difficult to read, maintain, and extend.

Problem 4: Objects Cannot Store Unique Data

Suppose you want to add a new student named Akash.

You would need to modify the class itself by adding new variables:

String studName4 = "Akash";
int studAge4 = 25;

Every time a new student is added, the class must be edited.

A well-designed class should not require modification whenever new objects are created.

To solve this we are using constructor.

What is a Constructor?

A constructor is a special member of a class that is automatically executed whenever an object is created.

Unlike ordinary methods, constructors are not called manually. Java automatically invokes them whenever an object is created using the new keyword.

A constructor has the following characteristics:

*It has the same name as the class.
*It does not have a return type, not even void.
*It executes automatically when an object is created.
*It is mainly used to initialize instance variables.

How Constructors Solve These Problems

Instead of creating separate variables for every student, we create only one name variable and one age variable.

String studName;
int studAge;

Now each object stores its own values.

To initialize these variables automatically, we use a constructor.

Program Using a Constructor

public class Building {

    static int age = 10;
    static String name = "Payilagam";

    String studName;
    int studAge;

    // Constructor
    public Building(String studName, int studAge) {
        this.studName = studName;
        this.studAge = studAge;
    }

    public void display() {
        System.out.println(studName + " " + studAge);
    }

    public static void main(String[] args) {

        Building student1 = new Building("Mohan", 22);
        Building student2 = new Building("Deva", 23);
        Building student3 = new Building("Madhavan", 24);

        System.out.println(Building.name);
        System.out.println(Building.age);

        student1.display();
        student2.display();
        student3.display();
    }
}

Program Using a Constructor screenshot:

How the Constructor Fixes the Problem

The constructor is

public Building(String studName, int studAge) {
    this.studName = studName;
    this.studAge = studAge;
}

Whenever an object is created, Java automatically passes the supplied values to the constructor.

For example,

Building student1 = new Building("Mohan", 22);

Java internally executes

this.studName = "Mohan";
this.studAge = 22;

Similarly,

Building student2 = new Building("Deva", 23);

stores

studName = Deva
studAge = 23

Each object now has its own unique data.

Understanding the Constructor

The constructor accepts two parameters.

public Building(String studName, int studAge)

Whenever Java creates an object, it automatically passes the supplied values to these parameters.

Inside the constructor,

this.studName = studName;
this.studAge = studAge;

the values received through the parameters are stored in the object's instance variables.

This ensures that every object is initialized immediately after creation.

What Does the `this` Keyword Mean?

Many beginners get confused by this line:

this.studName = studName;

Both variables have the same name, but they represent different things.

studName refers to the constructor parameter.
this.studName refers to the instance variable of the current object.

Therefore,

this.studName = studName;

means:

Store the value passed to the constructor inside the current object's studName variable.

Similarly,

this.studAge = studAge;

stores the age passed by the user inside the object's studAge variable.

The this keyword helps Java distinguish between instance variables and constructor parameters when they have the same name.

How Object Creation Works

Consider the following statement:

Building student1 = new Building("Mohan", 22);

When Java executes this line, two important things happen automatically.

Step 1: Memory Allocation

Java allocates memory for a new Building object.

Step 2: Constructor Execution

Immediately after creating the object, Java calls

Building("Mohan", 22)

Inside the constructor,

this.studName = "Mohan";
this.studAge = 22;

Now the object contains:

studName = Mohan
studAge = 22

The same process happens for every object.

When Java executes

Building student2 = new Building("Deva", 23);

the constructor initializes

studName = Deva
studAge = 23

Similarly,

Building student3 = new Building("Madhavan", 24);

creates another object containing

studName = Madhavan
studAge = 24

Although all three objects are created from the same class, each object stores different values.

Understanding the `display()` Method

The display() method prints the instance variables of the object that calls it.

public void display() {
    System.out.println(studName + " " + studAge);
}

When

student1.display();

is executed, the output is

Mohan 22

When

student2.display();

is executed, the output becomes

Deva 23

Similarly,

student3.display();

prints

Madhavan 24

The same method is used for all objects, but each object prints its own data because every object has its own instance variables.

Comparing Both Approaches

Without Constructor	With Constructor
One object stores details of multiple students.	One object represents one student.
Many variables like `studName1`, `studName2`, `studName3` are required.	Only one `studName` and one `studAge` variable are needed.
Every object contains the same data.	Every object stores its own data.
The class must be modified whenever a new student is added.	New students can be created simply by creating new objects.
Difficult to maintain.	Easy to maintain and extend.
Not a good object-oriented design.	Follows object-oriented programming principles.

Static vs Instance Variables in Java: Explained with Real-Life Examples and Programs

Madhavan G — Fri, 10 Jul 2026 15:29:26 +0000

What is a Static Variable?

A static variable belongs to the class, not to individual objects.

It is declared using the static keyword, and only one copy of the variable exists in memory, regardless of how many objects are created.

Characteristics of Static Variables

Declared using the static keyword.
Belongs to the class.
Only one copy exists.
Shared by all objects.
Memory is allocated only once when the class is loaded.
Accessed using the class name.

Syntax

class Student {
    static String institute = "Payilagam";
}

Accessing the static variable:

System.out.println(Student.institute);

Real-Life Example

Imagine the employees working in a company.

Every employee has a different name and employee ID, but the company name printed on every ID card is the same.

Employee 1
Name      : Mohan
Company   : Payilagam

Employee 2
Name      : Deva
Company   : Payilagam

Employee 3
Name      : Madhavan
Company   : Payilagam

Since the company name is common to every employee, it is a perfect example of a static variable.

What is a Non-Static (Instance) Variable?

A non-static variable, also called an instance variable, belongs to an individual object.

Whenever a new object is created, Java allocates a separate copy of every instance variable for that object.

Characteristics of Instance Variables

Declared without the static keyword.
Belongs to an object.
Every object has its own copy.
Memory is allocated whenever an object is created.
Accessed through an object reference.

Syntax

class Student {
    String name;
    int age;
}

Accessing an instance variable:

Student s = new Student();
System.out.println(s.name);

Real-Life Example

Each employee has a unique:

Name
Employee ID
Age

These values are different for every employee, so they should be stored as non-static variable(instance variables).

Example Program

public class Building {

    static int age = 10;
    static String name = "Payilagam";

    String studName1 = "Mohan";
    int studAge1 = 22;

    String studName2 = "Deva";
    int studAge2 = 23;

    String studName3 = "Madhavan";
    int studAge3 = 24;

    public static void main(String[] args) {

        Building student1 = new Building();
        Building student2 = new Building();
        Building student3 = new Building();

        System.out.println(Building.name);
        System.out.println(Building.age);

        System.out.println(student1.studName1 + " " + student1.studAge1);
        System.out.println(student1.studName2 + " " + student1.studAge2);
        System.out.println(student1.studName3 + " " + student1.studAge3);
    }
}

Program output Screenshot:

Understanding the Program

1. Why are static variables accessed using the class name?

System.out.println(Building.name);
System.out.println(Building.age);

Here, name and age are declared as static.

Since they belong to the class itself, there is no need to create an object to access them.

This is why we write:

Building.name

instead of

student1.name

2. Why can't a static method access instance variables directly?

The main() method is declared as static.

A static method belongs to the class, whereas instance variables belong to individual objects.

So if we write:

System.out.println(studName1);

Java doesn't know which object's studName1 should be accessed.

Therefore, the compiler displays the error:

non-static variable studName1 cannot be referenced from a static context

3. How do we access instance variables?

First, create an object.

Building student1 = new Building();

Now access the variable using that object.

System.out.println(student1.studName1);

Here,

student1 is the object.
studName1 belongs to that object.

The Problem in This Program:

Although the program works, it violates one of the most important principles of Object-Oriented Programming.

We created three objects.

Building student1 = new Building();
Building student2 = new Building();
Building student3 = new Building();

But every object contains all three students.

student1
Mohan
Deva
Madhavan

student2
Mohan
Deva
Madhavan

student3
Mohan
Deva
Madhavan

Every object stores the same information.

This defeats the purpose of creating multiple objects.

One Object Should Represent One Real-World Entity

One of the core principles of Object-Oriented Programming is:

One object should represent one real-world entity.

Instead of storing multiple students inside one object, each object should represent exactly one student.

Student Object 1
Name : Mohan
Age : 22

Student Object 2
Name : Deva
Age : 23

Student Object 3
Name : Madhavan
Age : 24

This design is cleaner, easier to maintain, and follows object-oriented principles.

How can we solve this problem:

By using Constructor in java we can solve this problem let discuss this in next blog.

Summary

Static Variable	Instance Variable
Belongs to the class	Belongs to an object
Declared using the `static` keyword	Declared without the `static` keyword
Only one copy exists	Every object has its own copy
Shared by all objects	Unique for every object
Memory allocated once when the class loads	Memory allocated whenever an object is created
Accessed using `ClassName.variable`	Accessed using `object.variable`
Stores common data	Stores object-specific data

Java Rules for Creating a Class, Data Types, and Static Variables

Madhavan G — Fri, 03 Jul 2026 07:42:22 +0000

Java is one of the most popular object-oriented programming languages used for developing desktop applications, web applications, mobile apps, and enterprise software. To write efficient Java programs, it is essential to understand the basic concepts such as creating a class, using different data types, and working with static variables. This article explains these concepts in a simple and easy-to-understand manner.

Java Rules for Creating a Class

A class is a blueprint for creating objects. It defines the properties (variables) and behaviors (methods) of an object.

Rules for Creating a Java Class

1. Class Name Should Start with a Letter

A Java class name must begin with an alphabet (A-Z or a-z), underscore (_), or dollar sign ($). However, it is recommended to start with a letter.

Valid Examples:

class Student
class Employee
class _Demo

Invalid Example:

class 123Student

2. Use Pascal Case Naming Convention

Java follows the Pascal Case naming convention for class names, where the first letter of every word is capitalized.

Examples:

Student
EmployeeDetails
BankAccount

3. Class Name Should Not Be a Java Keyword

Reserved keywords cannot be used as class names.

Invalid Examples:

class int
class public
class static

4. Only One Public Class Per File

If a class is declared as public, the filename must match the class name.

Example:

File Name: Student.java

public class Student {
}

5. Curly Braces Define the Class Body

Everything related to the class, such as variables, constructors, and methods, must be enclosed within curly braces { }.

Example:

public class Student {

    int id;
    String name;

    void display() {
        System.out.println(name);
    }

}

6. A Class Can Contain

Variables
Methods
Constructors
Nested Classes
Static Members

Example of a Java Class

public class Student {

    int id;
    String name;

    void display() {
        System.out.println("ID: " + id);
        System.out.println("Name: " + name);
    }

    public static void main(String[] args) {

        Student s = new Student();

        s.id = 101;
        s.name = "Rahul";

        s.display();
    }
}

Output:

ID: 101
Name: Rahul

Java Data Types

A data type specifies the type of value that a variable can store.

Java data types are divided into two categories:

Primitive Data Types
Non-Primitive (Reference) Data Types

1. Primitive Data Types

Primitive data types are predefined by Java and store simple values.

Data Type	Size	Example
byte	1 byte	100
short	2 bytes	2000
int	4 bytes	50000
long	8 bytes	9876543210L
float	4 bytes	12.5f
double	8 bytes	45.78
char	2 bytes	'A'
boolean	1 bit	true

Integer Example

public class IntegerExample {

    public static void main(String[] args) {

        int age = 25;

        System.out.println(age);
    }
}

Output

Double Example

public class DoubleExample {

    public static void main(String[] args) {

        double salary = 45000.75;

        System.out.println(salary);
    }
}

Output

45000.75

Character Example

public class CharacterExample {

    public static void main(String[] args) {

        char grade = 'A';

        System.out.println(grade);
    }
}

Output

Boolean Example

public class BooleanExample {

    public static void main(String[] args) {

        boolean isPassed = true;

        System.out.println(isPassed);
    }
}

Output

true

2. Non-Primitive Data Types

Non-primitive data types store references to objects rather than actual values.

Examples include:

String
Arrays
Classes
Interfaces
Objects

Example:

public class StringExample {

    public static void main(String[] args) {

        String name = "John";

        System.out.println(name);
    }
}

Output

John

Static Variable in Java

A static variable is a variable that belongs to the class rather than to individual objects. Only one copy of the static variable is created, and it is shared among all objects of the class.

Static variables are declared using the static keyword.

Syntax

class ClassName {

    static dataType variableName;

}

Characteristics of Static Variables

Belong to the class instead of objects.
Memory is allocated only once.
Shared among all objects.
Can be accessed using the class name.
Initialized when the class is loaded.

Example of a Static Variable

public class Student {

    int id;
    String name;

    static String college = "ABC College";

    Student(int i, String n) {
        id = i;
        name = n;
    }

    void display() {
        System.out.println(id + " " + name + " " + college);
    }

    public static void main(String[] args) {

        Student s1 = new Student(101, "Rahul");
        Student s2 = new Student(102, "Priya");

        s1.display();
        s2.display();
    }
}

Output

101 Rahul ABC College
102 Priya ABC College

Notice that both students share the same value for the college variable because it is declared as static.

Changing the Value of a Static Variable

If the value of a static variable changes, the updated value is reflected for all objects.

public class Student {

    static String college = "ABC College";

    public static void main(String[] args) {

        System.out.println(college);

        college = "XYZ University";

        System.out.println(college);
    }
}

Output

ABC College
XYZ University

Difference Between Static and Instance Variables

Static Variable	Instance Variable
Belongs to the class	Belongs to an object
Shared by all objects	Separate copy for each object
Created once	Created whenever an object is created
Accessed using the class name	Accessed using object references
Declared with the `static` keyword	Declared without the `static` keyword

Programming Paradigms

Madhavan G — Thu, 25 Jun 2026 08:20:35 +0000

What Is a Programming Paradigm?

A programming paradigm is a fundamental approach to writing computer programs. It defines how code is organized, how data is handled, and how problems are broken down into manageable parts.

Just as there are different styles of architecture for designing buildings, there are different programming paradigms for designing software. Each paradigm has its strengths and is suited to particular types of problems.

1.Procedural Programming:

Procedural programming is one of the oldest and most straightforward programming paradigms. In this approach, a program is organized as a sequence of procedures or functions that execute step by step.

The focus is on creating clear instructions that tell the computer exactly what to do and in what order.

Example:

void greet() {
    printf("Hello");
}

int main() {
    greet();
}

Key Characteristics:

Code is organized into procedures or functions.
Execution follows a logical sequence.
Easy to understand for beginners.
Suitable for smaller and medium-sized applications.

Common Languages:

C
Pascal
BASIC

Best Use Cases:

Procedural programming works well for applications that require straightforward execution flows, such as utilities, scripts, and system-level programming.

2.Object-Oriented Programming (OOP):

Object-Oriented Programming (OOP) organizes software around objects rather than functions. An object combines data (attributes) and behavior (methods) into a single unit.

The main goal of OOP is to model real-world entities and their interactions.

Example:

class Car:
    def start(self):
        print("Car started")

car = Car()
car.start()

Key Characteristics:

Uses classes and objects.
Supports encapsulation, inheritance, and polymorphism.
Encourages code reusability.
Makes large applications easier to manage.

Common Languages:

Java
C++
Python
C#

Best Use Cases:

OOP is widely used in enterprise applications, desktop software, mobile applications, and game development.

3.Functional Programming:

Functional programming treats computation as the evaluation of mathematical functions. Instead of changing data directly, it emphasizes immutable data and pure functions.

A pure function always produces the same output for the same input and has no side effects.

Example;

numbers = [1, 2, 3]
squared = list(map(lambda x: x * x, numbers))

Key Characteristics:

Functions are first-class citizens.
Avoids mutable state.
Encourages predictable and testable code.
Makes concurrent programming easier.

Common Languages:

Haskell
Lisp
Scala
F#

Best Use Cases:

Functional programming is commonly used in data processing, distributed systems, and applications requiring high reliability.

4.Declarative Programming:

Declarative programming focuses on describing what should be achieved rather than how to achieve it.

The programmer specifies the desired result, and the underlying system determines the execution strategy.

Example:

SELECT * FROM Employees
WHERE Salary > 50000;

In this example, you describe the data you want, not the detailed steps required to retrieve it.

Key Characteristics:

Emphasizes desired outcomes.
Reduces implementation complexity.
Often leads to concise and readable code.

Common Technologies:

SQL
HTML
CSS

Best Use Cases:

Declarative programming is widely used in database queries, web development, and configuration management.

5.Logic Programming:

Logic programming is based on formal logic. Instead of writing explicit instructions, developers define facts and rules, and the system uses logical reasoning to determine answers.

Example:

parent(john, mary).
parent(mary, sam).

The program stores relationships, and queries can be used to derive new information from them.

Key Characteristics:

Uses facts and rules.
Relies on automated reasoning.
Ideal for knowledge-based systems.

Common Languages:

Prolog
Datalog

Best Use Cases:

Logic programming is commonly used in artificial intelligence, expert systems, and rule-based applications.

Multi-Paradigm Programming Languages:

Modern programming languages are often designed to support multiple paradigms rather than being restricted to just one.

For example:

Python supports procedural, object-oriented, and functional programming.
Java primarily supports object-oriented and procedural programming.
JavaScript supports object-oriented, procedural, and functional programming.
C++ supports object-oriented, procedural, and generic programming.

This flexibility allows developers to choose the most appropriate style for a specific problem.

Why Are Programming Paradigms Important?

Understanding programming paradigms offers several benefits:

Better Problem Solving:

Different paradigms provide different tools and perspectives for solving problems efficiently.

Improved Code Organization:

Paradigms help structure code in a way that improves readability and maintainability.

Greater Flexibility:

Knowledge of multiple paradigms allows developers to select the best approach for each project.

Enhanced Career Growth:

Modern software development often requires familiarity with multiple programming styles and methodologies.

Understanding useMemo in React.

Madhavan G — Wed, 10 Jun 2026 08:53:32 +0000

What is useMemo?

useMemo is a React Hook used to store the result of an expensive calculation and only recalculate it when needed.

Syntax:

const memoizedValue = useMemo(() => {
  return calculation();
}, [dependencies]);

Parameters:

Callback Function: Contains the calculation whose result should be cached.
Dependencies Array: React recalculates the value only when one of these dependencies changes.

Return Value:
Returns the cached (memoized) value.

Why Do We Use useMemo?

Normally, when a React component re-renders, all the code inside it runs again.

This can become a problem if:

The component performs heavy calculations.
Large lists need filtering or sorting.
Expensive operations run repeatedly.

useMemo helps by:

✅ Improving performance

✅ Reducing unnecessary calculations

✅ Making applications more efficient

Without useMemo:

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

  const expensiveCalculation = () => {
    console.log("Calculating...");
    return 1000000 * 1000000;
  };

  const result = expensiveCalculation();

  return (
    <div>
      <h2>Result: {result}</h2>
      <button onClick={() => setCount(count + 1)}>
        Count: {count}
      </button>
    </div>
  );
}

Problem

Whenever the button is clicked:

State changes.
Component re-renders.
expensiveCalculation() runs again.
Performance may decrease.

Using useMemo:


import { useState, useMemo } from "react";

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

  const result = useMemo(() => {
    console.log("Calculating...");
    return 1000000 * 1000000;
  }, []);

  return (
    <div>
      <h2>Result: {result}</h2>
      <button onClick={() => setCount(count + 1)}>
        Count: {count}
      </button>
    </div>
  );
}

export default App;

What Happens?

Component renders for the first time.
useMemo calculates the value.
Value is stored in memory.
Clicking the button causes a re-render.
React reuses the stored value.
Calculation does not run again.

Understanding useEffect in React with Simple Examples

Madhavan G — Fri, 22 May 2026 08:45:22 +0000

React’s useEffect hook is one of the most important hooks for handling side effects in functional components.

You can use it to:

run code after rendering
fetch data
listen to changes
work with timers
update the DOM and much more.

The behavior of useEffect mainly depends on its dependency array.

Let’s understand it with practical examples.

1. Run Only Once (Component Mount)

Sometimes you want code to run only when the page loads for the first time.

Example:

API call on page load
Initial setup
Logging

Example:

import React, { useEffect } from "react";

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

  return <h1>Hello React</h1>;
}

export default App;

Why Does This Work?

An empty dependency array tells React:

“Run this effect only once after the initial render.”

Output:
Component Mounted

Only once when the component loads.

2. Run on Every Render:

Sometimes you want something to happen after every render.

Example:

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

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

  useEffect(() => {
    console.log("Rendered");
  });

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

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

export default App;

What Happens Here?

Since no dependency array is provided:

the effect runs after every render

This includes:

initial render
state updates
parent component re-renders

Output:

Rendered
Rendered
Rendered

Every render triggers the effect.

Important Note

Be careful with this pattern because unnecessary renders can affect performance.

3. Run When State Changes:

Suppose you want an effect to run only when a specific state changes.

Example:

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

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

  useEffect(() => {
    console.log("Count changed");
  }, [count]);

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

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

export default App;

What Happens?

Dependency Array
[count]
So the effect runs whenever count changes.

4. Two States, One Effect:

Now let’s say we have two state variables.

Example:

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

function App() {
  const [count, setCount] = useState(0);
  const [name, setName] = useState("");

  useEffect(() => {
    console.log("Effect ran");
  }, [count, name]);

  return (
    <div>
      <input
        type="text"
        placeholder="Enter name"
        value={name}
        onChange={(e) => setName(e.target.value)}
      />

      <h1>{count}</h1>

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

export default App;

What Happens?

The effect runs whenever:

count changes
OR name changes
Why?

React watches all values inside the dependency array.

If any dependency changes, the effect runs again.

What If Only count Is Added?
useEffect(() => {
console.log("Effect ran");
}, [count]);

Now:

changing count triggers the effect
changing name does NOT trigger the effect

This can sometimes create bugs if your effect also depends on name.

5. Derived Logic — Should It Be Inside useEffect?:

Suppose we want to show:

“Even Number”

whenever count becomes even.

Example:

import React, { useState } from "react";

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

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

      {count % 2 === 0 && <p>Even Number</p>}

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

export default App;

Why Not useEffect?

Because this is:

derived UI
not a side effect

useEffect should be used only for side effects like:

API calls
timers
subscriptions
localStorage updates

Basic react about Jsx and Component.

Madhavan G — Fri, 15 May 2026 08:45:14 +0000

What is JSX?

JSX stands for JavaScript XML. It is a syntax extension for JavaScript that allows developers to write HTML-like structures directly inside JavaScript code.

Example:

const element = <h1>Hello World</h1>;

Although JSX looks like HTML, browsers do not understand JSX directly. Tools like Babel convert JSX into regular JavaScript.

The above JSX code becomes:

React.createElement("h1", null, "Hello World");

Why Use JSX?

JSX is widely used because it makes code:

Easier to read
Cleaner and more organized
Faster to write
Simple to manage UI components

Instead of writing complex JavaScript code for UI creation, developers can use JSX to design interfaces in a more natural way.

Rules of JSX:

To write JSX correctly, developers must follow some important rules.

1.JSX Must Have One Parent Element:

JSX does not allow multiple elements without wrapping them inside a single parent element.

Correct Example:

return (
  <div>
    <h1>Welcome</h1>
    <p>This is JSX</p>
  </div>
);

Incorrect Example:

return (
  <h1>Welcome</h1>
  <p>This is JSX</p>
);

You can also use React Fragments:

return (
  <>
    <h1>Welcome</h1>
    <p>This is JSX</p>
  </>
);

2.All Tags Must Be Closed:

Every JSX tag must be properly closed.

Correct Example:

<img src="image.jpg" />
<input />

Incorrect Example:

<img src="image.jpg">

3. Use className Instead of class:

Since class is a reserved keyword in JavaScript, JSX uses className.

Correct Example

<div className="container">
  Content
</div>

Incorrect Example

<div class="container">
  Content
</div>

Use CamelCase for Attributes:

4.JSX attributes follow camelCase naming:

Examples
HTML Attribute=>JSX Attribute
onclick =>onClick
tabindex =>tabIndex
maxlength=>maxLength

Example:

<button onClick={handleClick}>
  Click Here
</button>

5.JavaScript Expressions Use Curly Braces {}

You can write JavaScript expressions inside JSX using curly braces.

Example

const name = "Rahul";

<h1>Hello {name}</h1>

You can also use calculations:

<h2>{5 + 5}</h2>

6.Inline CSS Must Be Written as an Object:

Styles in JSX are written as JavaScript objects.

Example:

<div style={{ color: "blue", fontSize: "20px" }}>
  Styled Text
</div>

Notice that property names use camelCase.

7.Comments in JSX:

Comments are written using {/* comment */} syntax.

Example

<div>
  {/* This is a JSX comment */}
  <h1>Hello</h1>
</div>

8.Component Names Must Start with a Capital Letter:

Custom React components should always begin with uppercase letters.

Correct Example:

<MyComponent />

Incorrect Example:

<myComponent />

Lowercase names are treated as normal HTML elements.

Advantages of JSX

Some major advantages of JSX are:

Improves code readability
Makes UI development easier
Reduces complexity
Supports reusable components
Provides better error handling

What are React Components?

React components are reusable pieces of code that return JSX and define how a part of the user interface should appear.

A component works like a JavaScript function that returns HTML-like UI code.

Example

function Welcome() {
  return <h1>Hello React</h1>;
}

The component can then be used like an HTML tag:

<Welcome />

Why Use Components?

Components provide several advantages:

Reusable code
Better organization
Easier maintenance
Improved readability
Faster development

Instead of writing the same code multiple times, developers can create one component and reuse it wherever needed.

Types of React Components:

There are mainly two types of components in React:

Functional Components
Class Components

1.Functional Components:

Functional components are simple JavaScript functions that return JSX.

They are the most commonly used components in modern React.

Example:

function Greeting() {
  return <h1>Welcome User</h1>;
}

Using the Component:

<Greeting />

Functional Component with Props

Props are used to pass data from one component to another.

Example

function Greeting(props) {
  return <h1>Hello {props.name}</h1>;
}

Using Props:

<Greeting name="Rahul" />

Output:
Hello Rahul

2.Class Components:

Class components are ES6 classes that extend React.Component.

Before hooks were introduced, class components were mainly used for state management.

Example

import React, { Component } from "react";

class Welcome extends Component {
  render() {
    return <h1>Hello React</h1>;
  }
}

Using the Component:

<Welcome />

Difference Between Functional and Class Components:
Functional Components|||Class Components
Simpler syntax||||||||More complex
Use hooks for state|||Use lifecycle methods
Faster and cleaner||||More boilerplate code
Mostly used today|||||Less commonly used

Rules for Naming Components:

React components should follow these rules:

Component names must start with a capital letter
Names should be meaningful
One component should focus on one task
Correct Example:

function Header() {
  return <h1>Website Header</h1>;
}

Incorrect Example

function header() {
  return <h1>Website Header</h1>;
}

Basic about React,Library and Framwork.

Madhavan G — Wed, 13 May 2026 14:08:09 +0000

What is React?

React is a free, open-source front-end JavaScript library used to build interactive user interfaces (UIs), particularly for single-page applications especially for:

•websites
•web apps
•dashboards
•mobile apps (through React Native)

React helps developers create apps using components.

Example:

•Navbar component
•Button component
•Profile card component
•Chat message component

These reusable pieces make apps easier to build and maintain.

Who Created React?

React was created by: Jordan Walke

while working at: Meta(previously Facebook)

React was first released publicly in 2013.

It was originally built to improve Facebook’s UI performance and complexity.

Why Was React Created?

Before React:

•Updating web pages dynamically was difficult
•large applications became messy
•DOM manipulation was slow and error-prone
•UI state management was hard

Developers frequently used:

•jQuery
•manual DOM updates
•lots of imperative code

React introduced a better approach:

•declarative UI
•component-based architecture
•efficient rendering

Why Do We Need React?

Without React, building complex UIs becomes harder as apps grow.

Imagine:

•Notifications updating
•Chat messages appearing
•Likes increasing
•Forms changing
•Live dashboards refreshing

Managing all this manually is difficult.

React helps by:

•Organizing UI into components
•Automatically updating the page when data changes
•Reducing repetitive code
•Improving maintainability

What is the difference between library and framwork?

Library

⇒A library is a collection of reusable functions or tools that you call when you need them.

⇒You are in control of the application flow.

Example:

If you use a math library:

add(2, 3)

Your code decides:

•when to call it
•how to use it
•how the app is structured

⇒Key idea
Your code calls the library

Framework:

A framework provides a structure and rules for building applications. It often controls the overall flow and calls your code at specific times.

Example

In a web framework:

•it decides routing
•lifecycle
•app structure
•startup flow

You plug your code into the framework.

⇒Key idea
The framework calls your code

This is often called Inversion of Control (IoC).

⇒Simple Analogy

•Library = toolbox
You pick tools when needed.

•Framework = house blueprint
The structure is already decided; you fill in parts.

what is build tool in react?

A build tool in React is software that automates the transformation of your source code (like JSX, TypeScript, and modern JavaScript) into optimized, browser-ready files. Because browsers cannot natively understand features like JSX or advanced ES6+ syntax, these tools act as a "bridge" to make your code functional and efficient for the web.

Popular build tools used in react:

Vite
Webpack
Parcel
Rspack
esbuild
Turbopack
Rollup

What is Vite?

Vite is a modern frontend build tool and development server used to build fast web applications, especially with React, Vue, and other frameworks.

It is designed to make development much faster and simpler compared to older tools like Webpack.

Closure in javascript.

Madhavan G — Wed, 06 May 2026 16:01:24 +0000

A closure is a fundamental concept in JavaScript where an inner function retains access to the variables of its outer function even after the outer function has finished executing. This occurs because the inner function keeps a reference to its original lexical environment, effectively "remembering" the scope it was created in.

How Closures Work:
In JavaScript, closures are created every time a function is defined inside another function.

⇒Lexical Scoping: JavaScript uses the physical location of a variable in the source code to determine its accessibility. Inner functions can look "up" the scope chain to find variables in outer functions.

⇒Persistence: Normally, local variables within a function are destroyed once that function finishes running. However, if an inner function uses those variables, the JavaScript engine keeps them in memory as long as that inner function exists.

Common Use Cases:
⇒Data Encapsulation (Private Variables): You can use closures to hide variables from the global scope, making them accessible only through specific methods.

⇒Function Factories: Generate multiple functions with pre-set configurations (e.g., creating specific adders like add5 or add10).

⇒State Preservation: Maintaining state in asynchronous operations, such as timers or API calls, where the function needs to remember context after a delay.

⇒Optimization: Implementing memoization or caching to store the results of expensive calculations.

Potential Downsides:
⇒Memory Leaks: Because closures keep variables in memory, they can lead to higher memory usage or leaks if long-lived closures hold onto large objects unnecessarily.

⇒Performance: Overusing nested functions and closures can introduce minor performance overhead due to the maintenance of the scope chain

Example:

Output:

JavaScript Array Iterations.

Madhavan G — Wed, 15 Apr 2026 15:42:16 +0000

What is Iteration?
Iterations refer to the process of repeating a block of code multiple times, usually using loops. It’s a fundamental concept used when you want to perform the same operation over a collection of data or until a condition is met.

JavaScript Array Iterations:

Array forEach
Array map()
Array flatMap()
Array filter()
Array reduce()
Array reduceRight()
Array every()
Array some()
Array from()
Array keys()
Array entries()
Array with()
Array Spread (...)
Array Rest (...)

⇒Array forEach:

•The forEach() method calls a function (a callback function) once for each array element.
Example:
let nums = [1, 2, 3];
nums.forEach(n => console.log(n * 2));

Note that the function takes 3 arguments:

The item value
The item index
The array itself
When a callback function uses only the value parameter, the index and array parameters can be omitted

Screenshot of the program:

⇒Array map():

The map() method creates a new array by performing a function on each array element.
The map() method does not execute the function for array elements without values.
The map() method does not change the original array.

Example:

let nums = [1, 2, 3, 4, 5];
let doubled = nums.map(n => n * 2);
console.log(doubled);

Screenshot of the program:

⇒Array flatMap():
•The flatMap() method first maps all elements of an array and then creates a new array by flattening the array.

Example:

let arr = [1, 2, 3, 4, 5];
let result = arr.flatMap(n => [n, n * 2]);
console.log(result);

Screenshot of the program:

⇒Array filter():
•The filter() method creates a new array with array elements that pass a test.

Example:

let nums = [1, 2, 3, 4];
let even = nums.filter(myFunction);
console.log(even);
function myFunction(value){
return (value%2===0)
}

Screenshot of the program:

⇒Array reduce():

The reduce() method runs a function on each array element to produce a single value.
The reduce() method works from left-to-right in the array. See also reduceRight().
The reduce() method does not reduce the original array.
In reduce(), the callback function is called for every element, and it receives 4 arguments:

array.reduce((accumulator, currentValue, index, array) =>
{
// logic
}, initialValue);

accumulator (acc):

👉The running result
•Stores the result from previous steps
•Updated and passed forward each iteration

2.currentValue (n / item):

👉 The current array element

3.index (optional):

👉 Position of current element

4.array (optional):

👉 Original array itself

Example:

let nums = [1, 2, 3, 4];
let sum = nums.reduce(myFunction,0)
function myFunction(acc,n){
return acc+n;
}
console.log(sum)

// In arrow funtion
let nums = [1, 2, 3, 4];
let sum = nums.reduce((acc, n) => acc + n, 0);
console.log(sum);//10

Screenshot of the program:

⇒Array reduceRight():

The reduceRight() method runs a function on each array element to produce a single value.
The reduceRight() works from right-to-left in the array. See also reduce().
The reduceRight() method does not reduce the original array.

Example:
let arr = ["1", "2", "3", "4"];
let result = arr.reduceRight(myFunction)
function myFunction(acc,n){
return acc+n;
}
console.log(result)

//In arrow funtion
let arr = ["1", "2", "3","4"];
let result = arr.reduceRight((acc, val) => acc + val);
console.log(result);

Screenshot of the program:

⇒Array every():

•The every() method checks if all array values pass the condition.

Example:

const numbers = [45, 4, 9, 16, 25];
let result = numbers.every(myFunction);
function myFunction(value, index, array) {
return value > 18;
}
console.log(result)

// In arrow funtion
// let number = [45,4,8,16,25];
// let result = number.every((val) =>val>18);
// console.log(result);

What does every() do?

👉 every() checks:

“Do ALL elements satisfy the condition?”

✔ If ALL are true → returns true
❌ If even ONE is false → returns false

Screenshot of the program:

JavaScript Callbacks.

Madhavan G — Tue, 14 Apr 2026 15:34:08 +0000

A JavaScript callback is a function passed as an argument to another function, which is then executed (or "called back") at a later point in time to complete a specific task.

This mechanism is fundamental to JavaScript's event-driven and asynchronous programming model.

What is a Callback Function?
A callback function is a function passed as an argument into another function.

A callback function is intended to be executed later.

Types of Callbacks
Asynchronous Callbacks:
Asynchronous callbacks are executed at a later time, allowing the main program to continue running without waiting.

This is essential for preventing the application from freezing during long-running tasks like network requests.

Synchronous Callbacks
Synchronous Callbacks are executed immediately within the outer function, blocking further operations until completion.

Array methods like map(), filter(), and forEach() use synchronous callbacks.

DEV Community: Madhavan G

What Is OOP in Java? Classes, Objects, and the Four Pillars.

What is OOPs?

Why Do We Need OOP?

What is a Class?

What is an Object?

Properties and Methods

1. Properties (Data)

2. Methods (Actions)

Example

Why Is OOP So Powerful?

The Four Pillars of Object-Oriented Programming (OOPs)

1. Encapsulation – Protecting Your Data

2. Inheritance – Reusing Existing Code

3. Polymorphism – One Method, Many Behaviors

Types of Polymorphism in Java

1. Compile-time Polymorphism (Method Overloading)

What is Compile-time Polymorphism?

Real-Life Example

Java Example

Rules for Method Overloading

2. Run-time Polymorphism (Method Overriding)

What is Run-time Polymorphism?

Real-Life Example

Java Example

Compile-time vs Run-time Polymorphism

Easy Trick to Remember

4. Abstraction – Hiding Complexity

Comparing the Four Pillars

Quick Summary

Understanding Constructors in Java: Why We Need Them and How They Solve Object Creation Problems.

This is the program we worked in the last blog

Program Without a Constructor

What Is the Problem with This Program?

Problem 1: One Object Contains Data for Multiple Students

Problem 2: Every Object Stores the Same Data

Problem 3: Not Scalable

Problem 4: Objects Cannot Store Unique Data

What is a Constructor?

How Constructors Solve These Problems

Program Using a Constructor

Program Using a Constructor screenshot:

How the Constructor Fixes the Problem

Understanding the Constructor

What Does the this Keyword Mean?

How Object Creation Works

Understanding the display() Method

Comparing Both Approaches

Static vs Instance Variables in Java: Explained with Real-Life Examples and Programs

What is a Static Variable?

Characteristics of Static Variables

Syntax

Real-Life Example

What is a Non-Static (Instance) Variable?

Characteristics of Instance Variables

Syntax

Real-Life Example

Example Program

Understanding the Program

1. Why are static variables accessed using the class name?

2. Why can't a static method access instance variables directly?

3. How do we access instance variables?

The Problem in This Program:

One Object Should Represent One Real-World Entity

How can we solve this problem:

Summary

Java Rules for Creating a Class, Data Types, and Static Variables

Java Rules for Creating a Class

Rules for Creating a Java Class

1. Class Name Should Start with a Letter

2. Use Pascal Case Naming Convention

3. Class Name Should Not Be a Java Keyword

4. Only One Public Class Per File

5. Curly Braces Define the Class Body

6. A Class Can Contain

Example of a Java Class

Java Data Types

1. Primitive Data Types

Integer Example

Double Example

What Does the `this` Keyword Mean?

Understanding the `display()` Method