DEV Community: Bala Murugan

Encapsulation in Java

Bala Murugan — Thu, 04 Jun 2026 06:33:47 +0000

What is Encapsulation:

Encapsulation is the process of binding data (variables) and methods into a single unit called a class. It is used to protect data from unauthorized access.

Encapsulation is achieved by:

Declaring variables as private.
Providing public getter and setter methods to access and update the data.

Why Use Encapsulation:

Provides data security.
Prevents unauthorized access.
Improves maintainability.
Provides better control over data.
Follows the principle of data hiding.

class Student {

    private String name;

    public void setName(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }
}

public class Main {

    public static void main(String[] args) {

        Student s = new Student();

        s.setName("Bala");

        System.out.println(s.getName());
    }
}

Output:

Bala

Access Modifiers in Java

Access modifiers control the visibility and accessibility of classes, variables, methods, and constructors.

There are four types of access modifiers:

Public
Private
Protected
Default
Public

A public member can be accessed from anywhere in the program

public class Demo {

    public int age = 22;
}

Access:

Same class
Same package
Different package
Subclass

Private

A private member can be accessed only within the same class.

class Demo {

    private int age = 22;
}

Access:

Same class
Same package
Different package
Subclass

Protected

A protected member can be accessed within the same package and by subclasses.

class Demo {

    protected int age = 22;
}

Access:

Same class
Same package
Different package
Subclass

Default

When no access modifier is specified, it becomes default access.

class Demo {

    int age = 22;
}

Access:

Same class
Same package
Different package
Subclass (different package)

Constructors in Java

Bala Murugan — Wed, 03 Jun 2026 09:20:23 +0000

What is a Constructor?

A Constructor is a special method in Java that is automatically called when an object is created.

It is used to initialize object values.

Key Features of Constructor:

Constructor name must be the same as the class name.

Constructor does not have a return type (not even void).

Constructor is called automatically when an object is created.

Used to initialize object data.

Syntax:

class ClassName {

    ClassName() {
        // Constructor body
    }
}

Example:

public class Student {

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

    public static void main(String[] args) {

        Student s1 = new Student();
    }
}

Output:

Constructor Called

How it Works?

Student s1 = new Student();
↓
Constructor is called automatically
↓
Output: Constructor Called.

Why Do We Use Constructors?

To initialize object values.
To reduce repetitive code.
To set default values when an object is created.
To make object creation easier.

Types of Constructors:

Default Constructor:

class Student {

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

Parameterized Constructor:

class Student {

    String name;

    Student(String name) {
        this.name = name;
    }

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

    public static void main(String[] args) {

        Student s1 = new Student("Bala");
        s1.display();
    }
}

Output:

Bala

Benefits of Method Overloading

Bala Murugan — Tue, 02 Jun 2026 11:36:38 +0000

What is a Method:

A method is a block of code that performs a specific task. The code inside the method executes only when the method is called.

Syntax:

returnType methodName(parameters) {
    // code
}

Example:

public class Demo {

    void greet() {
        System.out.println("Hello Bala");
    }

    public static void main(String[] args) {

        Demo obj = new Demo();
        obj.greet();
    }
}

Output:

Hello Bala

Why Use Methods?

Code Reusability
Reduces Code Duplication
Easy Maintenance
Better Readability

What is Method Overloading:

Method Overloading means creating multiple methods with the same name in the same class but with different parameters.

The parameters can differ by:

Number of parameters.
Type of parameters.
Order of parameters.

Example:

public class CalculatorOverloading {

    void add(int a, int b) {
        System.out.println(a + b);
    }

    void add(int a, int b, int c) {
        System.out.println(a + b + c);
    }

    public static void main(String[] args) {

        CalculatorOverloading obj =
            new CalculatorOverloading();

        obj.add(10, 20);
        obj.add(10, 20, 30);
    }
}

Output:

30
60

How It Works?

obj.add(10,20)
↓
Compiler calls:
add(int,int)

obj.add(10,20,30)
↓
Compiler calls:
add(int,int,int)

Why Use Method Overloading?

It allows us to use the same method name for performing similar operations.

It improves code readability and makes the program easier to understand.

It helps achieve Compile-Time Polymorphism in Java.

Static and NOn-static

Bala Murugan — Sat, 30 May 2026 14:01:14 +0000

static variable :

*A static Variable belongs to the class, not to an object.

nly one copy is created and shared by all objects.

Example:

class Student {

    static String college = "Bala";
}

public class Main {

    public static void main(String[] args) {

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

        System.out.println(s1.college);
        System.out.println(s2.college);
    }
}

Output:

Bala
Bala

Non-Static Variable (Instance Variable):

A non-static variable belongs to an object.

Every object gets its own copy of the variable.

Example:

class Student {

    String name;
}

public class Main {

    public static void main(String[] args) {

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

        s1.name = "Bala";
        s2.name = "Kumar";

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

Output:

Bala
Kumar

Explanation:

s1 → name = Bala
s2 → name = Kumar

Each object has a separate copy of name.

Key Differences:

Static Variable	Non-Static Variable
Belongs to class	Belongs to object
One copy only	Separate copy for each object
Shared by all objects	Not shared
Access using class name	Access using object

Data types in java

Bala Murugan — Fri, 29 May 2026 10:40:30 +0000

what is variable :

A variable is a container used to store data in memory during program execution.

It helps programmers store, update, and manipulate values in a program.

Each variable has:

a datatype
a variable name
a value

Example in Java:

int age = 21;

Here:

int → datatype
age → variable name
21 → value

Variables are important because they allow dynamic data handling and calculations in programming.

Types of Datatypes:

Primitive Datatypes
Non-Primitive Datatypes

Primitive Datatypes:

Primitive datatypes are predefined datatypes provided by Java.

There are 8 primitive datatypes:

byte
short
int
long
float
double
char
boolean

Example:

int age = 21;
double salary = 45000.50;
char grade = 'A';
boolean isPassed = true;

2.Non-Primitive Datatypes:

Non-primitive datatypes are user-defined or reference datatypes.

Examples:

String
Arrays
Classes
Objects

Example:

String name = "Bala";

Why do we use Datatypes?

Datatypes are used to define the type of data a variable can store.

They help the programming language understand:

what type of value is stored
how much memory should be allocated
what operations can be performed on the data

For example:

int is used for integer values
double is used for decimal values
char is used for single characters
boolean is used for true or false values

Example:

int age = 21;
double salary = 45000.50;

Using datatypes improves memory management, program efficiency, and data accuracy.

Example Program:

public class Main {

public static void main(String[] args) {

byte age = 21;

short year = 2026;

int marks = 450;

long population = 8000000L;

float height = 5.8f;

double salary = 45000.75;

char grade = 'A';

boolean isPassed = true;

System.out.println("Age: " + age);
System.out.println("Year: " + year);
System.out.println("Marks: " + marks);
System.out.println("Population: " + population);
System.out.println("Height: " + height);
System.out.println("Salary: " + salary);
System.out.println("Grade: " + grade);
System.out.println("Passed: " + isPassed);

}

Features of Java:

Bala Murugan — Thu, 28 May 2026 08:23:16 +0000

Features of Java:

Simple:

Java is easy to learn compared to C++.

No pointers
No complex memory handling
Clean and readable syntax

Meaning:

Java is simple because it removes complex programming features and keeps code easy to understand.

Object-Oriented:

Java is fully based on OOP concept.

Everything is written using:

Class
Object

OOP principles:

Encapsulation
Inheritance
Polymorphism
Abstraction

Meaning:

Java organizes code using objects, making it reusable and structured.

Platform Independent

Java works on any operating system.

Reason:
Java code is converted into bytecode and runs on JVM.

Meaning:

Write once, run anywhere (Windows, Linux, Mac)

Secure

Java is very secure.

No direct memory access
Runs inside JVM sandbox
Bytecode verification

Meaning:

Java prevents hacking and unsafe memory access.

Robust

Java is strong and reliable.

Automatic memory management (Garbage Collector)
Exception handling
No pointer issues

Meaning:

Java programs are stable and rarely crash.

High Performance:

Java is faster due to JIT compiler.

Converts bytecode to machine code during execution
Optimizes performance

Meaning:

Java runs fast for large applications.

Multithreaded

Java supports multiple tasks at the same time.

Example:

Music playing
File downloading

Meaning:

Java can handle multiple tasks simultaneously.

Portable

Java code can run on any system without modification.

Reason:
Same bytecode works everywhere with JVM.

Meaning:

Java programs are easily transferable across systems.

Introduction to Java

Bala Murugan — Thu, 28 May 2026 08:16:41 +0000

What is Java?

Java is a high-level programming language used to build:

Web applications
Mobile apps (Android)
Software systems

Java is Write Once, Run Anywhere (WORA) language
meaning: one code → can run in any OS (Windows, Linux, Mac)

Why Java?

Java is popular because:

✔ Platform Independent (any OS la run aagum)
✔ Secure (virus attack low)
✔ Object-Oriented (real world model easy)
✔ Easy memory management (Garbage Collector)
✔ Used in MNC companies (Cognizant, TCS, Infosys, etc.)

Java Architecture (Simple Diagram):

Java Program (.java)
↓
Compiler (javac)
↓
Bytecode (.class file)
↓
JVM (Java Virtual Machine)
↓
OS (Windows / Linux / Mac)
↓
Output

What is JVM?

JVM = Java Virtual Machine

✔ It is a virtual machine that runs Java bytecode
✔ Converts bytecode → machine code (OS understand pannum).

What is JIT Compiler?
JIT = Just In Time Compiler

✔ It is inside JVM
✔ Converts bytecode → fast machine code during runtime
✔ Improves performance

JRE (Java Runtime Environment):

JRE = JVM + libraries + runtime tools
What it does:
Provides environment to run Java programs
Contains:
JVM
Java class libraries
Supporting files

DK (Java Development Kit)
JDK = JRE + Development tools

What it contains:
JRE (for running programs)
JVM
Compiler (javac)
Debuggers and tools.

Relationship Diagram:

JDK
└── JRE
└── JVM

Python vs Java Comparison:

Feature	Python	Java ☕
Syntax	Very simple, less code	More complex, verbose
Learning	Easy for beginners	Moderate difficulty
Speed	Slower (interpreted)	Faster (JVM + JIT)
Typing	Dynamic typing	Static typing
Code length	Short	Long
Compilation	Interpreted	Compiled + Interpreted
Memory management	Automatic	Garbage Collector
OOP support	Supports OOP (flexible)	Fully object-oriented
Main use	AI, ML, Data Science	Enterprise apps, Android
Performance	Lower	Higher
Popularity	Data & AI field	Corporate + MNC systems

Introduction to Java

Bala Murugan — Wed, 27 May 2026 19:34:03 +0000

What is Java?

Java is a high-level programming language used to build:

Web applications
Mobile apps (Android)
Software systems

Java is Write Once, Run Anywhere (WORA) language
meaning: one code → can run in any OS (Windows, Linux, Mac)

Why Java?

Java is popular because:

Java Architecture (Simple Diagram):

Java Program (.java)
↓
Compiler (javac)
↓
Bytecode (.class file)
↓
JVM (Java Virtual Machine)
↓
OS (Windows / Linux / Mac)
↓
Output

What is JVM?

JVM = Java Virtual Machine

✔ It is a virtual machine that runs Java bytecode
✔ Converts bytecode → machine code (OS understand pannum).

What is JIT Compiler?
JIT = Just In Time Compiler

✔ It is inside JVM
✔ Converts bytecode → fast machine code during runtime
✔ Improves performance

JRE (Java Runtime Environment):

JRE = JVM + libraries + runtime tools
What it does:
Provides environment to run Java programs
Contains:
JVM
Java class libraries
Supporting files

DK (Java Development Kit)
JDK = JRE + Development tools

What it contains:
JRE (for running programs)
JVM
Compiler (javac)
Debuggers and tools.

Relationship Diagram:

JDK
└── JRE
└── JVM

Python vs Java Comparison:

Feature	Python	Java ☕
Syntax	Very simple, less code	More complex, verbose
Learning	Easy for beginners	Moderate difficulty
Speed	Slower (interpreted)	Faster (JVM + JIT)
Typing	Dynamic typing	Static typing
Code length	Short	Long
Compilation	Interpreted	Compiled + Interpreted
Memory management	Automatic	Garbage Collector
OOP support	Supports OOP (flexible)	Fully object-oriented
Main use	AI, ML, Data Science	Enterprise apps, Android
Performance	Lower	Higher
Popularity	Data & AI field	Corporate + MNC systems

React Unlocked: A Beginner’s Guide to Concepts, Tools & Modern Development

Bala Murugan — Fri, 17 Apr 2026 23:06:25 +0000

What is React?

React is a JavaScript library used to build user interfaces (UI), especially for single-page applications (SPA).

It was created by Facebook (Meta).

In simple words:
React helps you build fast and interactive websites like Instagram, Facebook, Netflix, etc.

Why use React?

React is popular because:

Fast performance (uses Virtual DOM)
Reusable components (write once, use anywhere) *Easy state management *Builds modern web apps easily
Huge community support

Example:

Instead of writing same button code again and again, React lets you create a Button component and reuse it everywhere.

What is Library and Framework?

Library:

*A library is a collection of pre-written code that you call when needed.

*You are in control.

Example:
React (UI library)
jQuery

*You decide when to use it.

Framework :

*A framework is a complete structure where the framework controls your code flow.

Framework is in control.

Example:
Angular
Django (Python framework)

         Difference between Library and Framework

Feature	Library	Framework
Control	You control	Framework controls
Flexibility	High	Less flexible
Usage	Specific task	Full application structure
Example	React	Angular

What is SPA ?

*SPA (Single Page Application)

 *A SPA loads only ONE HTML page and updates content dynamically.

Example:

Gmail
Facebook
Instagram

How it works:

*Page does NOT reload
*Only content changes
*Faster user experience

MPA (Multi Page Application)?

  A MPA loads a new page every time you click something.

Example:
Amazon
Traditional websites

How it works:

 *Every click loads a new HTML page
 *Full page refresh happens
 *Slower compared to SPA

              SPA vs MPA ?

Feature	SPA	MPA
Pages	One page	Multiple pages
Speed	Fast	Slower
Reload	No reload	Full reload
Example	React apps	Traditional websites

What is Create React App (CRA)?

   *Create React App (CRA) is a tool to set up a React project quickly.

Command:

npx create-react-app my-app

Problem:

Slow startup *Heavy build system *CRA is now less popular.

What is Vite?

*Vite is a modern build tool for React (and other frameworks).

*It is much faster than CRA.

Why Vite is popular:

*Very fast startup
*Instant hot reload
*Lightweight setup
*Better developer experience.

Command:

npm create vite@latest my-app

                       Learning Recap

*React = UI library for building web apps
*Library = you control flow
*Framework = full structure controls you
*SPA = single page, no reload
*MPA = multiple pages, reload happens
*CRA = old React setup tool
*Vite = modern, fast React tool

What is Node.js?

Node.js is a JavaScript runtime environment.

Node.js allows you to run JavaScript outside the browser (like in your computer terminal).

JavaScript runs only in the browser (Chrome, Firefox)

JavaScript can run on your system like Python or Java.

Why was Node.js created?

Before Node.js:

*JavaScript was only used for frontend (browser)

After Node.js:

*JavaScript can be used for backend, tools, servers, build systems.

Why Node.js is needed for React?

React does NOT run directly in the browser during development in raw form.

React code needs to be:

compiled
bundled
optimized

That’s where Node.js comes in.

      Main reasons Node.js is needed for React:

*Package Manager (npm / npx)

*Node.js comes with npm (Node Package Manager).

React needs npm to install libraries like:

react
react-dom
vite

Example:

npm install react

Without Node.js → no npm → no React setup.

Why Promises Are Better Than Callbacks

Bala Murugan — Sun, 29 Mar 2026 17:51:30 +0000

What is a Callback:

    A callback is a function that is passed as an argument to another function and executed later.

Example:

function greet(name, callback) {
  console.log("Hello " + name);
  callback();
}

function sayBye() {
  console.log("Bye!");
}

greet("Bala", sayBye);

Output:

Hello Bala
Bye!

What is Callback Hell:

When callbacks are nested inside other callbacks many times, it becomes hard to read and maintain. This is called Callback Hell.

Example:

setTimeout(() => {
  console.log("Step 1");

  setTimeout(() => {
    console.log("Step 2");

    setTimeout(() => {
      console.log("Step 3");

      setTimeout(() => {
        console.log("Step 4");
      }, 1000);

    }, 1000);

  }, 1000);

}, 1000);

This code looks like a pyramid shape.
This is called Callback Hell or Pyramid of Doom.

Problems in Callback Hell:
*Hard to read
*Hard to debug
*Hard to maintain
*Error handling is difficult

What is a Promise:

A Promise is used to handle asynchronous operations in a better way.

A Promise has 3 states:

Pending
Resolved (Success)
Rejected (Error)

Promise Example:

let promise = new Promise(function(resolve, reject) {
  let success = true;

  if (success) {
    resolve("Task completed");
  } else {
    reject("Task failed");
  }
});

promise
  .then(function(result) {
    console.log(result);
  })
  .catch(function(error) {
    console.log(error);
  });

Callback Hell vs Promise:

Callback Hell	Promise
Nested callbacks	Chain using `.then()`
Hard to read	Easy to read
Hard to maintain	Easy to maintain
Error handling difficult	Error handling easy with `.catch()`

Promise States Diagram:

Draw a simple flow:

         [Pending]
       /   \
      /     \

[Resolved] Rejected (Error)

              Real-World Example Diagram:

Use a food order example

CallbackHell:

Order Food
↓
Prepare Food
↓
Pack Food
↓
Deliver Food

Promise:

Order → Prepare → Pack → Deliver

You can end your blog like this:

",Callback Hell makes code messy. Promises make code clean, readable, and easy to manage."

Behind the Scenes of JavaScript: Synchronous vs Asynchronous Explained Simply

Bala Murugan — Sat, 28 Mar 2026 05:38:07 +0000

What is Synchronous JavaScript

Synchronous means code runs line by line, one after another.
Next line waits until the previous line finishes.

Example:

console.log("Start");

function slowTask() {
  for (let i = 0; i < 1e9; i++) {} // takes time
  console.log("Task Done");
}

slowTask();
console.log("End");

Output:
Start
Task Done
End

Explanation:

Here, End waits until slowTask finishes. This is Synchronous.

What is Asynchronous JavaScript?

Asynchronous means code does NOT wait.
It runs tasks in background and continues next lines.

Example:

console.log("Start");

setTimeout(() => {
  console.log("Task Done");
}, 2000);

console.log("End");

Output:
Start
End
Task Done

Explanation:

Here, End does NOT wait → This is Asynchronous.

Why Asynchronous is Needed :

Because JavaScript is single-threaded (one task at a time).
Async helps to handle:

API calls
Database calls
File reading
Timers
User actions

Without async → Website will freeze.

Asynchronous Methods in JavaScript:

There are 3 main ways:

Method	Use
Callback	Old method
Promise	Better
Async/Await	Best & modern

Callback Example:

function fetchData(callback) {
  setTimeout(() => {
    console.log("Data fetched");
    callback();
  }, 2000);
}

fetchData(() => {
  console.log("Process data");
});

Async/Await Example (Best Method):

function fetchData() {
  return new Promise((resolve) => {
    setTimeout(() => {
      resolve("Data fetched");
    }, 2000);
  });
}

async function getData() {
  let data = await fetchData();
  console.log(data);
}

getData();

Simple Difference Table

| Synchronous | Asynchronous |
| ----------------- | ------------------------ |
| Runs line by line | Runs in background |
| Waits | Does not wait |
| Blocking | Non-blocking |
| Slow | Fast |
| Example: for loop | Example: setTimeout, API |

Real Life Example

Synchronous:
*You stand in line and wait for tea → then go to next work.

Asynchronous:

   *You order tea → while tea is preparing, you do another work → then drink tea.

Event Loop Diagram

      ┌───────────────┐
    │   Call Stack   │
    └───────────────┘
            ↑
            │
    ┌───────────────┐
    │   Event Loop   │
    └───────────────┘
            ↑
            │
    ┌───────────────┐
    │ Callback Queue │
    └───────────────┘
            ↑
            │
    ┌───────────────┐
    │   Web APIs     │
    │ setTimeout     │
    │ API Calls      │
    │ DOM Events     │
    └───────────────┘

Explanation:

*Call Stack → Executes code
*Web APIs → Handle async work
*Callback Queue → Stores completed async tasks
*Event Loop → Moves task to Call Stack

JavaScript Closures Explained Simply with Examples

Bala Murugan — Fri, 27 Mar 2026 05:48:54 +0000

What is a Closure:

 A closure is a function that remembers the variables from its outer function even after the outer function has finished executing.

example:

function outer() {
  let name = "Bala";

  function inner() {
    console.log(name);
  }

  return inner;
}

const myFunction = outer();
myFunction();

Output:
Bala

step by step Explanation:
1.outer() function runs
2.Variable name is created
3.inner() function is returned
4.Even after outer() finishes, inner() still remembers name
5.This is called closure

       **Why Do We Use Closures in JavaScript**

Data privacy *To remember values *To avoid global variables *To maintain state *For callbacks and timers

Data Privacy (Real-World Example: Password):

We use closures to hide private data.

function createPassword() {
  let password = "12345";

  return function() {
    console.log(password);
  };
}

const getPassword = createPassword();
getPassword(); // 12345

Maintaining State (Real-World Example: Counter)

 Closures help to remember previous value.

function counter() {
  let count = 0;

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

const c = counter();
c(); // 1
c(); // 2
c(); // 3

Used in setTimeout / Callbacks

function greet(name) {
  setTimeout(function() {
    console.log("Hello " + name);
  }, 2000);
}

greet("Bala");

       **How Closure Works (Lexical Scope)**

What is Lexical Scope

 A function can access variables from its parent (outer) function based on where the function is written in the code.

simple:

 * Inner function → can access outer variables.

 * Outer function → cannot access inner variables.

Example : Lexical Scope?

function outer() {
  let name = "Bala";

  function inner() {
    console.log(name);
  }

  inner();
}

outer();

Merits of Closures

*Data privacy

State management *Avoid global variables *Used in callbacks *Used in real-world applications