DEV Community: Karthick Karthick

"Why Can't the Main Class Be Protected in Java? Understanding Access Rules and Inheritance"

Karthick Karthick — Sat, 13 Jun 2026 06:18:41 +0000

Introduction

In Java, access modifiers define the visibility and accessibility of classes, methods, and variables. A common question among beginners is "Why can't a main class be declared as protected?" The answer lies in Java's rules for top-level classes and access control

Can a Top-Level Class Be protected?

No. A top-level class (a class declared directly inside a .java file) cannot be declared as protected.

protected class Main { public static void main(String[] args) { System.out.println("Hello Java"); } }

Why Is protected Not Allowed for the Main Class?

protected Works Through Inheritance

The protected access modifier is designed to allow access:

Inside the same package.
In child classes (subclasses), even if they are in different packages.

A top-level class does not have a parent class that needs to control access through inheritance, so protected has no meaningful purpose for it.

Java Allows Only public or Default for Top-Level Classes

Java language rules allow only two access levels for top-level classes:

public → Accessible from anywhere.
default (no modifier) → Accessible only within the same package.

private and protected are only allowed for class members or nested classes.

JVM Must Be Able to Locate the Main Class

When a Java program starts, the JVM needs to load the class containing the main() method.

A top-level class must follow Java's accessibility rules, which means it can be public or default, but not protected.

Can a Nested Class Be protected?

Yes. A class declared inside another class (nested class) can use the protected access modifier.
`class Outer {

protected class Inner {
    void display() {
        System.out.println("Protected Nested Class");
    }
}

"Why Can't the Main Class Be Private in Java? Understanding Access Rules and JVM Execution"

Karthick Karthick — Sat, 13 Jun 2026 06:14:11 +0000

Introduction

In Java, access modifiers control the visibility of classes, methods, and variables. One common question among beginners is "Why can't a main class be private?" Understanding this requires knowledge of how the Java compiler and Java Virtual Machine (JVM) access classes.

What is a Main Class in Java?

A main class is the class that contains the main() method, which serves as the entry point of a Java application.

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

Why Can't a Top-Level Class Be Private?

In Java, a top-level class (a class declared directly in a file, not inside another class) can only have two access modifiers:

public
Default (no access modifier)

A top-level class cannot be

private class Main { public static void main(String[] args) { System.out.println("Hello Java"); } }

Why Is private Not Allowed for the Main Class?

Private Means Restricted Access

A private class can only be accessed within its enclosing class. Since a top-level class has no enclosing class, making it private would make no practical sense.

JVM Needs Access to the Class

When you run a Java program, the JVM needs to locate and load the class containing the main() method. If the main class were private, external code would not be able to access it.

Java Follows Access Control Rules

Java's access modifiers are designed to control visibility:

public → Accessible from anywhere.
Default → Accessible within the same package.
private → Accessible only inside the same class.
protected → Accessible within the package and subclasses.

Since a top-level class is not inside another class, private and protected are not applicable.

Can the main() Method Be Private?

No. The main() method must be declared as public static void main(String[] args).

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

Can a Main Class Have Default Access?

Yes. A main class can have default (package-private) access.

class Main { public static void main(String[] args) { System.out.println("Java Program"); } }

Understanding Polymorphism in Java: Types, Examples, and Real-Time Applications

Karthick Karthick — Sat, 13 Jun 2026 06:00:40 +0000

Polymorphism in Java: A Complete Beginner's Guide
Introduction

Polymorphism is one of the four main principles of Object-Oriented Programming (OOP) in Java. The word Polymorphism comes from two Greek words: "Poly" meaning many and "Morph" meaning forms. It allows a single entity such as a method or object to take multiple forms.

In simple words, one name can have many behaviors.

What is Polymorphism in Java?

Polymorphism is the ability of an object or method to perform different actions based on the situation. It enables Java to use a single interface to represent different implementations.

*Why Do We Need Polymorphism?
*
Polymorphism is used to make programs more flexible, reusable, and easy to maintain.

Reasons for Using Polymorphism:

Code Reusability
The same method name can be reused for different tasks.
Flexibility
Allows one interface to work with multiple implementations.
Easy Maintenance
Changes can be made in one part of the program without affecting the entire application.
Extensibility
New classes and functionalities can be added easily.
Improved Readability
Makes the code cleaner and easier to understand.

Types of Polymorphism in Java:

Compile-Time Polymorphism
Runtime Polymorphism

Compile-Time Polymorphism (Static Polymorphism)

Compile-time polymorphism is achieved through Method Overloading. The compiler decides which method to call based on the number or type of parameters.
`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;
}

}

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

    Calculator obj = new Calculator();

    System.out.println(obj.add(10, 20));
    System.out.println(obj.add(10, 20, 30));
    System.out.println(obj.add(10.5, 20.5));
}

Runtime Polymorphism (Dynamic Polymorphism)

Runtime polymorphism is achieved through Method Overriding. The method that gets executed is determined at runtime based on the actual object.
`class Animal {

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

}

class Dog extends Animal {

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

}

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

    Animal obj = new Dog(); // Upcasting

    obj.sound();
}

Advantages of Polymorphism

Increases code reusability
Provides flexibility
Improves scalability
Makes applications easier to maintain
Supports dynamic method execution
Reduces code complexit

Java Explained: Who Created It, Why It Was Developed, and Why It Is So Popular

Karthick Karthick — Sat, 13 Jun 2026 05:44:35 +0000

What is the Full Form of Java?

Java does not have any official full form. It is simply a name chosen for the programming language. Many people jokingly expand it as "Just Another Virtual Accelerator (JAVA)", but this is not an official meaning.

Why Was It Named Java? Who Named It?

Java was developed by James Gosling and his team at Sun Microsystems.
Initially, the language was named Oak because an oak tree stood outside James Gosling’s office.
Later, the name Oak could not be used because it was already trademarked by another company.
The team selected the name Java, inspired by Java coffee (coffee beans from the Indonesian island of Java).
The name was chosen during a team discussion while they were drinking coffee

Why Was Java Created?

Java was created in 1991 under a project called the Green Project at Sun Microsystems.

The main goals were:

Platform Independence
A program should run on different devices without rewriting the code.
Simple and Easy to Learn
Java was designed with a syntax similar to C and C++ but removed complex features like manual memory management.
Secure Programming
It included features like bytecode verification and controlled memory access.
Support for Different Devices
Originally, it was created for consumer electronic devices such as televisions and embedded systems.

Why Is Java Efficient?

Java became popular because it provides a balance between performance, simplicity, and security.

Reasons for Java’s Efficiency

Platform Independence

Java follows the principle "Write Once, Run Anywhere" because programs run on the Java Virtual Machine (JVM).

Automatic Memory Management

Java has Garbage Collection, which automatically removes unused objects and manages memory.

Just-In-Time (JIT) Compilation

The JVM converts frequently used bytecode into native machine code, improving execution speed.

Object-Oriented Design

Java provides reusable and maintainable code using classes, objects, inheritance, and polymorphism.

Strong Security

Features like bytecode verification, access control, and the JVM sandbox improve application security.

Large Community and Ecosystem

Java has a huge developer community, many libraries, frameworks, and tools.Why Is Java Efficient?

Java became popular because it provides a balance between performance, simplicity, and security.

Reasons for Java’s Efficiency

Platform Independence

Java follows the principle "Write Once, Run Anywhere" because programs run on the Java Virtual Machine (JVM).

Automatic Memory Management

Java has Garbage Collection, which automatically removes unused objects and manages memory.

Just-In-Time (JIT) Compilation

The JVM converts frequently used bytecode into native machine code, improving execution speed.

Object-Oriented Design

Java provides reusable and maintainable code using classes, objects, inheritance, and polymorphism.

Strong Security

Features like bytecode verification, access control, and the JVM sandbox improve application security.

Large Community and Ecosystem

Java has a huge developer community, many libraries, frameworks, and tools.

Inheritance in Java: Types, Examples, Advantages, and Complete Guide for Beginners

Karthick Karthick — Sat, 13 Jun 2026 05:33:58 +0000

Inheritance in Java: A Complete Beginner's Guide
Introduction

Inheritance is one of the fundamental concepts of Object-Oriented Programming (OOP) in Java. It allows one class to acquire the properties and behaviors (variables and methods) of another class. Inheritance promotes code reusability, maintainability, and supports runtime polymorphism.

What is Inheritance in Java?

Inheritance is a mechanism where one class (called the child class or subclass) inherits the fields and methods of another class (called the parent class or superclass) using the extends keyword.

Syntax:

`class Parent {
// Variables and methods
}

class Child extends Parent {
// Additional features
}`

Types of Inheritance in Java:

Single Inheritance
Multilevel Inheritance
Hierarchical Inheritance
Multiple Inheritance (Not Supported with Classes)
Hybrid Inheritance

Single Inheritance

A child class inherits from one parent class

`class Animal {
void eat() {}
}

class Dog extends Animal {
void bark() {}
}`

Multilevel Inheritance

A class inherits from another child class, forming a chain.

`class Animal {
void eat() {}
}

class Dog extends Animal {
void bark() {}
}

class Puppy extends Dog {
void weep() {}
}`

Hierarchical Inheritance

Multiple child classes inherit from a single parent class

`class Animal {
void eat() {}
}

class Dog extends Animal {
void bark() {}
}

class Cat extends Animal {
void meow() {}
}`

Multiple Inheritance (Not Supported with Classes)

In multiple inheritance, one child class inherits from multiple parent classes.

`interface A {
void show();
}

interface B {
void display();
}

class C implements A, B {

public void show() {
    System.out.println("Show");
}

public void display() {
    System.out.println("Display");
}

Hybrid Inheritance

Hybrid inheritance is a combination of two or more types of inheritance.

Java does not support hybrid inheritance using classes because it includes multiple inheritance.

However, it can be achieved using interfaces.

Advantages of Inheritance

Code Reusability – Write common code once and reuse it.
Method Overriding – Allows runtime polymorphism.
Better Code Organization – Creates a logical class hierarchy.
Easy Maintenance – Changes in the parent class can be reused by child classes

Understanding Access Modifiers in Java: Public, Private, Protected, and Default Explained

Karthick Karthick — Sat, 13 Jun 2026 05:25:37 +0000

Access Modifiers in Java: A Complete Beginner's Guide
Introduction

Access modifiers in Java are keywords that control the visibility and accessibility of classes, variables, methods, and constructors. They provide encapsulation and help protect data by restricting unauthorized access from other parts of a program.

What are Access Modifiers in Java?

Access modifiers define who can access a particular class member (variable, method, or constructor). Java provides four types of access modifiers:

public
private
protected
default (no modifier)

Public Access Modifier

The public access modifier allows a class, method, or variable to be accessed from anywhere in the program, even from different packages.

Private Access Modifier

The private access modifier allows access only within the same class. It cannot be accessed directly from outside the class.

Protected Access Modifier

The protected modifier allows access within the same package and by subclasses (child classes), even if they are in different packages.

. Default Access Modifier

When no access modifier is specified, it is called default or package-private access. It can be accessed only within the same package.

Why are Access Modifiers Used?

To protect sensitive data.
To implement encapsulation.
To control the visibility of classes and class members.
To improve code security and maintainability.
To prevent accidental modification of data

What is Java? History, Uses, Datatypes, Variables, and OOP Concepts Explained

Karthick Karthick — Mon, 01 Jun 2026 17:19:37 +0000

What is Java? Why is it Used? How Was It Created? Datatypes and Variables in Java
Introduction
Java is one of the most popular programming languages in the world. It is widely used for developing web applications, desktop software, mobile applications, enterprise systems, and cloud-based solutions. Java follows the principle:
"Write Once, Run Anywhere (WORA)"
This means Java programs can run on different operating systems without modifying the code.
What is Java?
Java is a high-level, object-oriented, platform-independent programming language developed by James Gosling and his team at Sun Microsystems in 1995.
Java code is compiled into bytecode, which runs on the Java Virtual Machine (JVM). This allows Java applications to work on Windows, Linux, macOS, and many other platforms.
Simple Java Program
Java
public class Main {
public static void main(String[] args) {
System.out.println("Hello, Java!");
}
}
Output

Hello, Java!
Why is Java Used?
Java is popular because it offers:

Platform Independence Java programs can run on any device with a JVM.
Object-Oriented Programming Java uses classes and objects, making applications easier to develop and maintain.
Security Java provides built-in security features and memory management.
High Performance The JVM uses Just-In-Time (JIT) compilation to improve execution speed.
Large Community Support Millions of developers use Java worldwide.
Enterprise Applications
Large companies use Java for banking, e-commerce, and business applications.
How Was Java Created?
In 1991, a team led by James Gosling at Sun Microsystems started a project called Green Project.
Evolution of Java
Year
Event
1991
Green Project Started
1994
Language renamed to Java
1995
Java officially released
2010
Sun Microsystems acquired by Oracle Corporation
Present
Java remains one of the most used languages
How Many Days Does It Take to Learn Java?
Learning time depends on your experience and dedication.
Beginner Roadmap
Level
Time Required
Java Basics
2–3 Weeks
OOP Concepts
2 Weeks
Collections & Exception Handling
2 Weeks
JDBC & Database
1–2 Weeks
Advanced Java
3–4 Weeks
Projects Practice
Ongoing
Recommended Timeline
1 Hour Daily → 3–4 Months
2–3 Hours Daily → 1–2 Months
4+ Hours Daily → 3–6 Weeks
Datatypes in Java
A datatype specifies the type of data a variable can store.
Java has 8 Primitive Datatypes.
Datatype
Size
Example
byte
1 byte
100
short
2 bytes
20000
int
4 bytes
50000
long
8 bytes
100000L
float
4 bytes
10.5f
double
8 bytes
20.55
char
2 bytes
'A'
boolean
1 bit
true
Example
Java
public class DataTypes {
public static void main(String[] args) {
```
int age = 21;
double salary = 50000.50;
char grade = 'A';
boolean isStudent = true;

System.out.println(age);
System.out.println(salary);
System.out.println(grade);
System.out.println(isStudent);
```
}
}
Output

21
50000.5
A
true
Non-Primitive Datatypes
These are created by programmers or provided by Java libraries.
String
Arrays
Classes
Interfaces
Objects
Example
Java
String name = "Ak";
Variables in Java
A variable is a container used to store data values.
Syntax
Java
datatype variableName = value;
Example
Java
int age = 21;
String name = "Ak";
Types of Variables in Java

Local Variable Declared inside a method. Java public void display() { int num = 10; }
Instance Variable Declared inside a class but outside methods. Java class Student { int id; } Each object gets its own copy.
Static Variable
Declared using the static keyword.
Java
class Student {
static String college = "ABC College";
}
Shared by all objects.
Method Overloading Example
Method Overloading allows multiple methods with the same name but different parameters.
Java
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;
}
}

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

    Calculator obj = new Calculator();

    System.out.println(obj.add(10, 20));
    System.out.println(obj.add(10, 20, 30));
    System.out.println(obj.add(10.5, 20.5));
}

}
Output

30
60
31.0
Conclusion
Java is a powerful, secure, and platform-independent programming language used for building everything from mobile applications to enterprise software. By understanding Java's history, uses, datatypes, variables, and method overloading concepts, beginners can build a strong foundation for learning advanced Java topics such as OOP, Collections, JDBC, Spring Boot, and Full Stack Development.

Mastering React Through a Quiz Application Project

Karthick Karthick — Mon, 01 Jun 2026 17:02:11 +0000

Building a Quiz Application in React Using useState, useEffect, useContext, and useNavigate

Introduction

Quiz applications are one of the best beginner-to-intermediate React projects because they demonstrate important React concepts such as state management, component communication, routing, and side effects.

In this project, I developed a Quiz Application using React and implemented several powerful hooks including useState, useEffect, useContext, and useNavigate. The application allows users to answer questions, track scores, navigate between pages, and view results dynamically.

Project Overview

The Quiz Application consists of the following features:

Home Page
Quiz Page
Multiple Choice Questions
Score Tracking
Result Page
Dynamic Navigation
Global State Management

Users start the quiz, answer questions one by one, and receive their final score at the end.

Technologies Used

React.js
JavaScript (ES6+)
HTML5
CSS3
React Router DOM
React Hooks

Application Workflow

Step 1: Start Quiz

The user lands on the home page and clicks the "Start Quiz" button.

Step 2: Answer Questions

Questions are displayed one at a time with multiple options.

Step 3: Score Calculation

The application checks whether the selected answer is correct and updates the score.

Step 4: View Results

After completing all questions, the user is redirected to the results page where the final score is displayed.

useState Hook

Purpose

The useState Hook is used to manage local component state.

How It Was Used

In the Quiz Application, useState manages:

Current Question Index
Selected Answer
User Score
Quiz Completion Status

Example

const [score, setScore] = useState(0);
const [currentQuestion, setCurrentQuestion] = useState(0);

Benefits

Dynamic UI updates
Easy state management
Interactive user experience

useEffect Hook

Purpose

The useEffect Hook is used to perform side effects in React components.

How It Was Used

In the Quiz Application, useEffect helps:

Load quiz data
Monitor question changes
Execute actions when the quiz ends

Example

useEffect(() => {
console.log("Question Changed");
}, [currentQuestion]);

Benefits

Handles lifecycle events
Improves application responsiveness
Executes logic automatically when dependencies change

useContext Hook

Purpose

The useContext Hook allows sharing data across multiple components without passing props manually.

How It Was Used

A Quiz Context was created to store:

User Score
Quiz Questions
Current Progress
Quiz Status

Example

const QuizContext = createContext();

const value = {
score,
setScore
};

Accessing Context:

const { score } = useContext(QuizContext);

Benefits

Eliminates prop drilling
Centralized state management
Cleaner component structure

useNavigate Hook

Purpose

The useNavigate Hook is provided by React Router and enables programmatic navigation.

How It Was Used

The application navigates users between pages:

Home → Quiz
Quiz → Results
Results → Home

Example

const navigate = useNavigate();

navigate("/quiz");

Benefits

Smooth page transitions
Better user experience
Dynamic routing control

Project Structure

src/
│
├── components/
│ ├── Home.jsx
│ ├── Quiz.jsx
│ └── Result.jsx
│
├── context/
│ └── QuizContext.jsx
│
├── data/
│ └── questions.js
│
├── App.jsx
└── main.jsx

Challenges Faced

State Synchronization

Managing score updates across components required proper state management.

Navigation Flow

Ensuring users could not access the results page before completing the quiz required route control.

Context Management

Sharing data globally without prop drilling was solved using useContext.

Key Learning Outcomes

Through this project, I learned:

React Component Architecture
State Management with useState
Side Effects with useEffect
Global Data Sharing with useContext
Routing with useNavigate
Building Real-World React Applications

Future Improvements

Possible enhancements include:

Timer-based quizzes
Difficulty Levels
Leaderboard System
User Authentication
Database Integration
Category-Based Questions

Conclusion

The Quiz Application is an excellent React project that demonstrates practical usage of useState, useEffect, useContext, and useNavigate. These hooks work together to create a dynamic, responsive, and user-friendly application. Building this project helped strengthen my understanding of React fundamentals and provided hands-on experience with real-world development concepts.

React.js Complete Guide: What It Is, Why It’s Used, Who Created It, and Essential Hooks

Karthick Karthick — Mon, 01 Jun 2026 16:51:07 +0000

What is React? Why is it Used? Who Created It? And Understanding React Hooks

Introduction

React is one of the most popular JavaScript libraries used for building modern web applications. From social media platforms to e-commerce websites, React powers thousands of applications worldwide because of its speed, flexibility, and component-based architecture.

In this article, we will explore what React is, why it is used, who created it, and some of the most important React Hooks such as useState, useEffect, useContext, useNavigate, useReducer, useRef, useMemo, and useCallback.

What is React?

React is an open-source JavaScript library used for building user interfaces (UI), especially for Single Page Applications (SPAs).

Instead of updating an entire webpage, React updates only the parts of the page that change, making applications faster and more efficient.

Key Features of React

Component-Based Architecture
Virtual DOM
Reusable Components
One-Way Data Binding
Fast Rendering
Large Community Support

Who Created React?

React was created by , a software engineer at "about.meta.com" (https://reference-url-citation.invalid/1).

Timeline

2011 – React was first used internally by Facebook.
2012 – Used in Instagram.
2013 – Released as an open-source project.
Today – Used by companies around the world.

Why is React Used?

React became popular because it solves many challenges in traditional web development.

Reusable Components

Developers can create a component once and use it multiple times.

Example:

function Welcome() {
return

Welcome User

;
}

Better Performance

React uses a Virtual DOM to update only changed elements instead of refreshing the entire page.

Easy Maintenance

Applications are divided into smaller components, making code easier to manage.

Strong Community Support

Millions of developers contribute tutorials, libraries, and tools.

Rich Ecosystem

React works well with:

Redux
React Router
Axios
Firebase
Node.js

What are React Hooks?

Hooks are special functions introduced in React 16.8 that allow developers to use state and other React features inside functional components.

Before Hooks, these features were available only in class components.

useState Hook

The useState Hook is used to manage state in functional components.

Syntax

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

Example

import { useState } from "react";

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

return (
<>

{count}

setCount(count + 1)}>
Increment

</>
);
}

Use Cases

Counter applications
Form handling
Toggle buttons

useEffect Hook

The useEffect Hook is used to perform side effects.

Examples:

API Calls
Timers
Event Listeners
Updating Document Title

Example

import { useEffect } from "react";

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

return

Hello React

;
}

Use Cases

Fetching data
Browser events
Synchronizing external systems

useContext Hook

The useContext Hook allows data sharing across multiple components without prop drilling.

Example

const UserContext = createContext();

function Home() {
const user = useContext(UserContext);

return

{user}

;
}

Use Cases

Authentication
Theme management
Language settings

useNavigate Hook

The useNavigate Hook is provided by React Router.

It allows navigation between pages programmatically.

Example

import { useNavigate } from "react-router-dom";

function Home() {
const navigate = useNavigate();

return (
navigate("/about")}>
Go To About

);
}

Use Cases

Login redirection
Navigation after form submission

useReducer Hook

useReducer is used for complex state management.

Syntax

const [state, dispatch] = useReducer(reducer, initialState);

Example

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

Use Cases

Shopping carts
Dashboards
Complex forms

useRef Hook

useRef creates a mutable reference that persists across renders.

Example

import { useRef } from "react";

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

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

return (
<>

Focus
</>
);
}

Use Cases

DOM access
Focus management
Storing previous values

useMemo Hook

useMemo is used to optimize performance by memoizing expensive calculations.

Example

const result = useMemo(() => {
return heavyCalculation(data);
}, [data]);

Use Cases

Large datasets
Filtering operations
Expensive calculations

useCallback Hook

useCallback memoizes functions to prevent unnecessary re-creation.

Example

const handleClick = useCallback(() => {
console.log("Clicked");
}, []);

Use Cases

Optimizing child components
Preventing unnecessary renders

Difference Between useMemo and useCallback

useMemo| useCallback
Memoizes values| Memoizes functions
Returns computed value| Returns function
Used for calculations| Used for event handlers

Advantages of React

Fast Performance
Reusable Components
Easy Learning Curve
Strong Community
Rich Ecosystem
SEO Friendly
Scalable Applications

Understanding Compile-Time Polymorphism in Java

Karthick Karthick — Mon, 01 Jun 2026 16:49:17 +0000

Compile-Time Polymorphism in Java
Introduction
Polymorphism is one of the most important concepts in Java. The word "polymorphism" comes from two Greek words:

Poly = Many
Morph = Forms
It allows a single method or object to behave in different ways.
Compile-Time Polymorphism is a type of polymorphism where the method to be executed is determined by the compiler during compilation.
It is also known as:
Static Polymorphism
Early Binding
Method Overloading
What is Compile-Time Polymorphism?
Compile-Time Polymorphism occurs when multiple methods have the same name but different parameter lists. The compiler decides which method should be called based on the arguments passed.
class Calculator {

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

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

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

}

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

    Calculator c = new Calculator();

    System.out.println(c.add(10, 20));
    System.out.println(c.add(10.5, 20.5));
    System.out.println(c.add(10, 20, 30));
}

}
Output:
30
31.0
60

Method Overloading Rules:
Number of Parameters Changes
Data Type Changes
Order of Parameters Changes

Advantages of Compile-Time Polymorphism
Code Reusability
Same method name can perform similar tasks.
Readability
Program becomes easier to understand.
Flexibility
Methods can handle different types of input.
Faster Execution
Method calls are resolved during compilation.

React vs JavaScript: Why Developers Prefer React for UI Projects

Karthick Karthick — Tue, 07 Apr 2026 06:01:23 +0000

Introduction

If you’ve ever built a small project like a calculator, to-do app, or counter, you might have noticed something interesting:

The same app feels harder in JavaScript
But feels easier in React At first, this sounds confusing…

Because React is built on JavaScript

So how can something built on JavaScript feel easier than JavaScript itself?

Let’s break it down like a real content creator would — simple, clear, and practical
The Core Idea (Understand This First)

JavaScript = You control everything manually
React = You describe what you want, React handles the rest

Building a Calculator in JavaScript (What Actually Happens)

When you build a calculator using plain JavaScript, you usually:

Select buttons using DOM (getElementById, querySelector)
Add event listeners to every button
Store values (current number, operator, result)
Manually update the display
Handle edge cases (clear, delete, decimal, etc.)

Reality:

You are doing two jobs at the same time

Business logic (calculations)
UI updates (changing what user sees)

That’s why it feels complex.

Building the Same Calculator in React

In React, things change completely.

You:

Create components (Button, Display, Calculator)
Store values in state
Update state on click
React updates the UI automatically

Reality:

You only focus on:

“What is my data?”
“What should UI show?”

React handles everything else.

Why React Feels Easier:

Components = Clean Structure

In React, everything is divided into small parts:

Display
Buttons
Calculator Logic

Each part has its own job

In JavaScript:

Everything is often mixed together

State = Easy Data Management

React uses state to store changing values.

Example:

Current number
Previous number
Operator

When state changes → UI updates automatically

In JavaScript:

You must update variables AND update UI manually

No More Manual DOM Work

In JavaScript:

document.getElementById(...)
innerText = value

In React:

Just update state
React updates UI

This saves a LOT of effort

Reusability is Super Easy

<Button value="1" /> <Button value="2" /> <Button value="+" />

Better for Bigger Projects

Small apps → JavaScript is fine
Big apps → React is powerful

Examples:

E-commerce
Dashboards
Chat apps
Payment systems

React keeps things organized

API in JavaScript: Connecting Your Code to the World

Karthick Karthick — Wed, 01 Apr 2026 05:46:18 +0000

An API (Application Programming Interface) in JavaScript is a way for your code to communicate with other software, services, or systems.

In simple words:
API = Bridge between your JavaScript and external data/services

Real-Time Example

In Pharmacy E-Commerce :

User clicks “Buy Now”
JS sends request to payment API (like Razorpay)
API processes payment
JS gets response → shows Success / Failed

API Methods in JavaScript

GET (Read Data)
Used to fetch data from server

fetch("https://api.example.com/products")
  .then(res => res.json())
  .then(data => console.log(data));

POST (Create Data)
Used to send new data to server

fetch("https://api.example.com/products", {
  method: "POST",
  body: JSON.stringify({ name: "Tablet", price: 100 }),
  headers: { "Content-Type": "application/json" }
});

PUT (Update Full Data)
Used to update entire data

fetch("https://api.example.com/products/1", {
  method: "PUT",
  body: JSON.stringify({ name: "Tablet", price: 120 }),
  headers: { "Content-Type": "application/json" }
});

PATCH (Update Partial Data)
Used to update only specific fields

fetch("https://api.example.com/products/1", {
  method: "PATCH",
  body: JSON.stringify({ price: 120 }),
  headers: { "Content-Type": "application/json" }
});

DELETE (Remove Data)
Used to delete data

fetch("https://api.example.com/products/1", {
  method: "DELETE"
});

Types of APIs in JavaScript (Quick View)

Browser APIs → DOM, Geolocation
Third-party APIs → Payment (Razorpay), Maps
Custom APIs → Your backend (Python/Node)