DEV Community: Athithya Sivasankarar

Understanding Method Overriding in Java

Athithya Sivasankarar — Wed, 15 Jul 2026 08:43:23 +0000

One of the key features of Object-Oriented Programming (OOP) in Java is Method Overriding. It allows a subclass to provide its own implementation of a method that is already defined in its parent class. This helps achieve runtime polymorphism, making Java programs more flexible and reusable.

In this blog, we'll learn what method overriding is with a simple example.

What is Method Overriding?

Method Overriding is a feature in Java where a child class provides a specific implementation of a method that is already present in the parent class.

To override a method:

The parent and child class methods must have the same method name.
They must have the same parameters.
They must have the same return type (or a compatible one).

Example

class Animal {

void sound() {
    System.out.println("Animals make sounds.");
}

}

class Dog extends Animal {

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

}

public class Main {

public static void main(String[] args) {

    Dog d = new Dog();

    d.sound();

}

}

Output

Dog barks.

Explanation

The "Animal" class contains a method called "sound()".
The "Dog" class extends "Animal" and overrides the "sound()" method.
When the "sound()" method is called using the "Dog" object, Java executes the overridden method in the child class.

Advantages of Method Overriding

Achieves Runtime Polymorphism.
Improves code flexibility.
Allows subclasses to customize inherited methods.
Promotes code reusability.

Conclusion

Method overriding is an important Java concept that allows a child class to redefine the behavior of a method inherited from its parent class. It plays a major role in achieving runtime polymorphism and makes applications more flexible and maintainable.

Method Overriding means redefining an inherited method in a child class using the same method signature to provide a different implementation.

Understanding Java Access Modifiers

Athithya Sivasankarar — Tue, 14 Jul 2026 08:50:38 +0000

When learning Java, one of the first Object-Oriented Programming (OOP) concepts you'll encounter is Access Modifiers. They control the visibility and accessibility of classes, variables, methods, and constructors.
Java provides four access modifiers:
public
private
protected
default (no access modifier)
In this blog, we'll explore each access modifier with simple examples to help beginners understand them easily.
What are Access Modifiers?
Access Modifiers are Java keywords that define where a class, method, variable, or constructor can be accessed.
They help provide security, encapsulation, and controlled access to data.
Why Do We Need Access Modifiers?
Access modifiers help us:
Protect sensitive data.
Prevent unauthorized access.
Improve code security.
Support Object-Oriented Programming principles.
Control how different classes interact with each other.

Public Access Modifier
The public access modifier allows a class member to be accessed from anywhere in the program.
Example
class Student {

public String name = "Athithya";

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

public class Main {

public static void main(String[] args) {

    Student s = new Student();

    s.display();

}

}
Output
Student Name: Athithya
Explanation
Since the variable and method are declared as public, they can be accessed from any class.

Private Access Modifier
The private access modifier allows access only within the same class.
Example
class BankAccount {

private int balance = 5000;

public void showBalance() {
System.out.println(balance);
}

}

public class Main {

public static void main(String[] args) {

    BankAccount account = new BankAccount();

    account.showBalance();

}

}
Output
5000
Explanation
The variable balance cannot be accessed directly outside the class.
The following code will produce an error:
System.out.println(account.balance);
This improves data security.

Protected Access Modifier
The protected access modifier allows access:
Within the same class
Within the same package
In subclasses (inheritance), even if they are in different packages
Example
class Animal {

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

}

class Dog extends Animal {

void bark() {
    sound();
}

}

public class Main {

public static void main(String[] args) {

    Dog d = new Dog();

    d.bark();

}

}
Output
Animal makes a sound
Explanation
Since Dog inherits Animal, it can access the protected method.

Default Access Modifier
If no access modifier is specified, Java automatically assigns the default access modifier.
It is accessible only within the same package.
Example
class Employee {

String department = "Cyber Security";

void display() {
```
System.out.println(department);
```
}

}

public class Main {

public static void main(String[] args) {

    Employee e = new Employee();

    e.display();

}

}
Output
Cyber Security
Explanation
Since no access modifier is written, both the variable and method have default access.
They can be accessed only within the same package.

Understanding Constructors and Constructor Overloading in Java

Athithya Sivasankarar — Fri, 10 Jul 2026 07:34:31 +0000

What is a Constructor?

A constructor is a special method that is automatically called whenever an object of a class is created.

Unlike normal methods, a constructor:

Has the same name as the class.
Does not have a return type (not even void).
Is executed automatically when an object is created using the new keyword.

Syntax

class ClassName {

    ClassName() {
        // Constructor body
    }

}

Why Do We Need Constructors?

Constructors help us:

Initialize object variables.
Reduce repetitive code.
Ensure objects start with valid values.
Improve code readability.

Example 1: Default Constructor

class Student {

    Student() {
        System.out.println("Student object created successfully.");
    }

    public static void main(String[] args) {

        Student s1 = new Student();

    }
}

Output

Student object created successfully.

Explanation

When the statement

Student s1 = new Student();

is executed,

Java automatically calls the constructor

Student()

which prints the message.

Example 2: Constructor Initializing Variables

class Product {

    String name;
    int price;

    Product() {
        name = "Rice";
        price = 1500;
    }

    void display() {
        System.out.println("Product Name : " + name);
        System.out.println("Price : " + price);
    }

    public static void main(String args[]) {

        Product p1 = new Product();

        p1.display();

    }
}

Output

Product Name : Rice
Price : 1500

Explanation

The constructor assigns default values to the object variables. Whenever a new object is created, these values are automatically initialized.

Types of Constructors

Java mainly has two types of constructors.

1. Default (No-Argument) Constructor

A constructor that does not take any parameters.

Example:

Student() {

}

2. Parameterized Constructor

A constructor that accepts parameters.

Example:

Student(String name, int age) {

}

Parameterized constructors allow us to initialize objects with different values.

What is Constructor Overloading?

Constructor Overloading means having multiple constructors in the same class with different parameter lists.

Each constructor performs a different type of object initialization.

Java determines which constructor to call based on the arguments passed while creating the object.

Example of Constructor Overloading

class Employee {

    String name;
    int age;

    Employee() {
        name = "Unknown";
        age = 0;
    }

    Employee(String n) {
        name = n;
        age = 0;
    }

    Employee(String n, int a) {
        name = n;
        age = a;
    }

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

    public static void main(String args[]) {

        Employee e1 = new Employee();

        Employee e2 = new Employee("Athithya");

        Employee e3 = new Employee("Athithya", 20);

        e1.display();

        e2.display();

        e3.display();

    }

}

Output

Unknown 0
Athithya 0
Athithya 20

How Constructor Overloading Works

When these statements execute,

Employee e1 = new Employee();

Java calls

Employee()

When

Employee e2 = new Employee("Athithya");

Java calls

Employee(String n)

When

Employee e3 = new Employee("Athithya", 20);

Java calls

Employee(String n, int a)

Java chooses the constructor based on the number and type of arguments provided.

Advantages of Constructor Overloading

Provides multiple ways to initialize objects.
Makes programs more flexible.
Improves code readability.
Reduces the need for multiple initialization methods.
Supports object-oriented programming principles.

Difference Between Constructors and Methods

Constructor	Method
Same name as the class	Can have any valid name
No return type	Has a return type or `void`
Called automatically	Called explicitly
Used to initialize objects	Used to perform operations

Understanding the "this" Keyword in Java Using a SuperMarket Example

Athithya Sivasankarar — Tue, 07 Jul 2026 08:47:01 +0000

What is the "this" Keyword?

The "this" keyword is a reference variable that refers to the current object of a class.

Whenever an object calls a method, "this" refers to that particular object. It is commonly used to access instance variables and methods of the current object.

Program Example

public class SuperMarket {

String name;
int price;

public static void main(String args[]) {

    SuperMarket prod1 = new SuperMarket();

    prod1.name = "Rice";
    prod1.price = 1500;

    prod1.buy();
}

void buy() {

    // this refers to the current object
    System.out.println(this.price);
    System.out.println(this.name);
}

}

Output

1500
Rice

Explanation

Step 1: Creating an Object

SuperMarket prod1 = new SuperMarket();

This statement creates an object named "prod1".

Step 2: Assigning Values

prod1.name = "Rice";
prod1.price = 1500;

The object now stores the following values:

Variable| Value
name| Rice
price| 1500

Step 3: Calling the Method

prod1.buy();

When the "buy()" method is called, the keyword "this" refers to the object "prod1".

Therefore,

this.price

is equivalent to

prod1.price

and

this.name

is equivalent to

prod1.name

As a result, the values stored in the object are printed on the screen.

Why Use the "this" Keyword?

The "this" keyword improves code readability and helps Java identify the current object's variables and methods.

It becomes especially useful when local variables and instance variables have the same name.

Example:

class Product {

String name;

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

}

In the above code:

"this.name" refers to the instance variable.
"name" refers to the constructor parameter.

Without "this", Java cannot differentiate between the two variables.

Advantages of Using "this"

Refers to the current object.
Improves code readability.
Helps access instance variables and methods.
Useful in constructors.
Supports constructor chaining.
Makes object-oriented programming easier to understand.

Static vs Non-Static in Java

Athithya Sivasankarar — Mon, 06 Jul 2026 08:02:18 +0000

What Does `static` Mean?

A static member belongs to the class, not to any specific object.

This means you can use it without creating an object of the class.

Example

class Student {
    static String school = "ABC School";
}

public class Main {
    public static void main(String[] args) {
        System.out.println(Student.school);
    }
}

In this example, school is static. Since it belongs to the class, I can access it using the class name without creating a Student object.

What Does Non-Static Mean?

A non-static member belongs to an object of the class.

To use it, I must first create an object.

Example

class Student {
    String name = "John";
}

public class Main {
    public static void main(String[] args) {
        Student s = new Student();
        System.out.println(s.name);
    }
}

Here, name is non-static. Every object can have its own value for name.

Static vs Non-Static

Static	Non-Static
Belongs to the class	Belongs to an object
No object is needed	Object is required
Shared by all objects	Each object has its own copy
Accessed using the class name	Accessed using the object

A Simple Real-Life Example

Imagine a classroom.

The school name is the same for every student. So it makes sense to keep it static.
The student's name is different for each student. So it should be non-static.

class Student {
    static String school = "ABC School";
    String name;

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

If I create two students:

Student s1 = new Student("Alice");
Student s2 = new Student("Bob");

Then:

Student.school → "ABC School" (same for everyone)
s1.name → "Alice"
s2.name → "Bob"

This helped me understand why static data is shared while non-static data is unique for each object.

Why Is `main()` Static?

One question I had was:

Why do we write public static void main(String[] args)?

The reason is simple.

When the Java program starts, no objects have been created yet. Java needs a method it can call immediately, so it makes the main() method static.

That's why Java can run the program without creating an object first.

Can a Static Method Access Non-Static Variables?

No, not directly.

For example:

class Test {
    int x = 10;

    static void display() {
        System.out.println(x); // Error
    }
}

This gives an error because x belongs to an object, but the static method doesn't know which object to use.

The correct way is:

class Test {
    int x = 10;

    static void display() {
        Test t = new Test();
        System.out.println(t.x);
    }
}

When Should We Use `static`?

Use static when:

The value is common to every object.
You don't need object-specific data.
You want to call a method without creating an object.

Examples include:

Constants
Utility methods
The main() method
Shared counters

Java Programming Language – Overview

Athithya Sivasankarar — Mon, 29 Jun 2026 16:50:13 +0000

Java is a high-level, object-oriented, and platform-independent programming language developed by James Gosling at Sun Microsystems in 1995. It is one of the most widely used programming languages for developing web applications, desktop software, mobile applications, enterprise systems, and cloud-based solutions.

The main philosophy of Java is "Write Once, Run Anywhere" (WORA), which means that Java programs can run on any device that has a Java Virtual Machine (JVM). This feature makes Java highly portable and suitable for cross-platform development.

Java follows Object-Oriented Programming (OOP) concepts such as Encapsulation, Inheritance, Polymorphism, and Abstraction. These concepts help developers create reusable, maintainable, and scalable applications.

One of the key strengths of Java is its platform independence. Java source code is compiled into bytecode, which is executed by the JVM. As a result, the same Java program can run on different operating systems without modification.

Java is also known for its security and robustness. It provides features such as automatic memory management through garbage collection, exception handling, and strong type checking. These features help reduce programming errors and improve application reliability.

The Java ecosystem consists of three major components: JDK (Java Development Kit), JRE (Java Runtime Environment), and JVM (Java Virtual Machine). The JDK is used for developing Java applications, the JRE is used for running Java programs, and the JVM executes Java bytecode.

Java is widely used in various domains, including web development, enterprise software, Android application development, banking systems, e-commerce platforms, cloud computing, and Internet of Things (IoT) applications. Popular frameworks such as Spring Boot and Hibernate further enhance Java's capabilities.

Some important features of Java include platform independence, object-oriented programming, security, robustness, multithreading, high performance, and portability. These features have made Java one of the most popular programming languages in the world.

In conclusion, Java is a powerful and versatile programming language that continues to play a major role in modern software development. Its platform independence, object-oriented nature, and extensive ecosystem make it an excellent choice for building secure, scalable, and efficient applications.

useReducer in React

Athithya Sivasankarar — Thu, 04 Jun 2026 18:14:31 +0000

When building React applications, we often use useState to manage state. But when the state logic becomes more complex, React provides another Hook called useReducer.

useReducer helps us manage state changes in a more organized way by using a reducer function and actions.

What is useReducer?

useReducer is a React Hook used for state management.

It works similarly to Redux because it uses:

State – Current data.
Action – What operation should be performed.
Reducer Function – Decides how the state should change.

Syntax

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

Parameters

reducerFunction → Function that updates the state.
initialState → Starting value of the state.

Returns

state → Current state value.
dispatch() → Function used to send actions to the reducer.

Example: Counter Application

Code

import React, { useReducer } from 'react'

function App() {

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

      case "decrement":
        return { count: state.count - 1 }

      case "reset":
        return { count: 0 }

      default:
        return state
    }
  }

  const [state, dispatch] = useReducer(reducerFn, { count: 0 });

  return (
    <div>
      <h1>Count : {state.count}</h1>

      <button onClick={() => dispatch({ type: "increment" })}>
        +
      </button>

      <button onClick={() => dispatch({ type: "decrement" })}>
        -
      </button>

      <button onClick={() => dispatch({ type: "reset" })}>
        Reset
      </button>
    </div>
  )
}

export default App

When Should You Use useReducer?

Use useReducer when:

State logic becomes complex.
Multiple state updates are needed.
Different actions update the same state.
Building larger applications.

React Quiz App

Athithya Sivasankarar — Tue, 02 Jun 2026 07:46:19 +0000

Step 1: Create Context in App.jsx

App.jsx

import { BrowserRouter, Route, Routes } from 'react-router-dom'
import './App.css'
import Home from './components/Home'
import Questions from './components/Questions'
import Result from './components/Result'
import { createContext, useState } from 'react'

export const quizContext = createContext();

function App() {

  const [user, setUser] = useState("");
  const [score, setScore] = useState(0);

  return (
    <div>

      <BrowserRouter>

        <quizContext.Provider
          value={{ user, setUser, score, setScore }}
        >

          <Routes>
            <Route path='/' element={<Home />} />
            <Route path='/quiz' element={<Questions />} />
            <Route path='/result' element={<Result />} />
          </Routes>

        </quizContext.Provider>

      </BrowserRouter>

    </div>
  )
}

export default App

Step 2: Create Home Page

Home.jsx

import { useContext, useEffect, useRef } from "react";
import { quizContext } from "../App";
import { useNavigate } from "react-router-dom";

function Home() {

  const { user, setUser } = useContext(quizContext);

  const userRef = useRef();

  const navigate = useNavigate();

  useEffect(() => {
    userRef.current.focus();
  }, []);

  function startGame() {

    if (user) {
      navigate("/quiz");
    }
    else {
      alert("Enter user name to Start quiz");
    }

  }

  return (
    <div>

      <input
        ref={userRef}
        value={user}
        type="text"
        placeholder="Enter userName"
        onChange={(e) => setUser(e.target.value)}
      />

      <button onClick={startGame}>
        Start quiz
      </button>

    </div>
  );
}

export default Home;

Step 3: Create Questions Data

Create a JSON file for storing quiz questions.

questions.json

[
  {
    "prompt": "HTML stands for?",
    "optionA": "HyperText Markup Language",
    "optionB": "HyperText Mark Language",
    "optionC": "HyperText Markup Learn",
    "optionD": "Hyper Markup Language",
    "answer": "optionA"
  }
]

Step 4: Questions Component

import React, { useContext, useState } from 'react'
import questions from '../assets/questions.json'
import { quizContext } from '../App';
import { useNavigate } from 'react-router-dom';

function Questions() {
  const navigate = useNavigate()
  const [currentQuestion, setCurrentQuestion] = useState(0);
  const [optionChosen, setOptionChosen] = useState("");
  const { score, setScore } = useContext(quizContext);


  function nextQuestion() {

    if (optionChosen == questions[currentQuestion].answer) {
      setScore(score + 1)
    }
    setCurrentQuestion(currentQuestion + 1)
  }

  function finishQuestion() {
    if (optionChosen == questions[currentQuestion].answer) {
      setScore(score + 1)
    }
    navigate('/result')
  }

  return (
    <div>
      <h1>{questions[currentQuestion].prompt}</h1>
      {
        ['A', 'B', 'C', 'D'].map((v) => (
          <button onClick={() => setOptionChosen(`option${v}`)}>{questions[currentQuestion][`option${v}`]}</button>
        ))
      }
      {currentQuestion == questions.length - 1 ? <button onClick={finishQuestion}>Finish</button> : <button onClick={nextQuestion}>Next</button>}

    </div>
  )
}

export default Questions

Step 5: Result Page

The Result page displays the final score.

Result.jsx

import React, { useContext } from 'react'
import { quizContext } from '../App'

function Result() {

  const { user, score } = useContext(quizContext)

  return (
    <div>

      <h1>Result</h1>

      <h2>
        {user} Total Mark Scored is {score}/5
      </h2>

    </div>
  )
}

export default Result

React useContext + useNavigate Scenarios

Athithya Sivasankarar — Fri, 29 May 2026 08:00:59 +0000

1. Login Scenario

Problem

User enters name in Login page and moves to Dashboard page.
Dashboard should display the username.

App.jsx

import React, { createContext, useState } from "react";
import { BrowserRouter, Routes, Route } from "react-router-dom";

import Login from "./components/Login";
import Dashboard from "./components/Dashboard";

export const UserContext = createContext();

function App() {

  const [user, setUser] = useState("");

  return (

    <UserContext.Provider value={{ user, setUser }}>

      <BrowserRouter>

        <Routes>

          <Route path="/" element={<Login />} />

          <Route
            path="/dashboard"
            element={<Dashboard />}
          />

        </Routes>

      </BrowserRouter>

    </UserContext.Provider>

  );
}

export default App;

Login.jsx

import React, { useState, useContext } from "react";
import { useNavigate } from "react-router-dom";
import { UserContext } from "../App";

function Login() {

  const [name, setName] = useState("");

  const { setUser } = useContext(UserContext);

  const navigate = useNavigate();

  const handleLogin = () => {
    setUser(name);
    navigate("/dashboard");
  };

  return (
    <div>

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

      <button onClick={handleLogin}>
        Login
      </button>

    </div>
  );
}

export default Login;

Dashboard.jsx

import React, { useContext } from "react";

import { UserContext } from "../App";

function Dashboard() {

  const { user } = useContext(UserContext);

  return (

    <div>

      <h1>Dashboard</h1>

      <h2>Welcome {user}</h2>

    </div>

  );
}

export default Dashboard;

2. Logout Scenario

Problem

User clicks Logout button and should return to Login page.
Stored user data should also be cleared.

App.jsx

import React, { createContext, useState } from "react";
import { BrowserRouter, Routes, Route } from "react-router-dom";

import Login from "./components/Login";
import Dashboard from "./components/Dashboard";

export const UserContext = createContext();

function App() {
  const [user, setUser] = useState("");

  return (
    <UserContext.Provider value={{ user, setUser }}>
      <BrowserRouter>
        <Routes>
          <Route path="/" element={<Login />} />
          <Route path="/dashboard" element={<Dashboard />} />
        </Routes>
      </BrowserRouter>
    </UserContext.Provider>
  );
}

export default App;

Login.jsx

import React, { useState, useContext } from "react";
import { useNavigate } from "react-router-dom";
import { UserContext } from "../App";

function Login() {
  const [name, setName] = useState("");

  const { setUser } = useContext(UserContext);

  const navigate = useNavigate();

  const handleLogin = () => {
    setUser(name);
    navigate("/dashboard");
  };

  return (
    <div>
      <h1>Login</h1>

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

      <button onClick={handleLogin}>
        Login
      </button>
    </div>
  );
}

export default Login;

Dashboard.jsx

import React, { useContext } from "react";
import { useNavigate } from "react-router-dom";
import { UserContext } from "../App";

function Dashboard() {

  const { setUser } = useContext(UserContext);

  const navigate = useNavigate();

  const handleLogout = () => {
    setUser("");
    navigate("/");
  };

  return (
    <div>

      <button onClick={handleLogout}>
        Logout
      </button>

    </div>
  );
}

export default Dashboard;

3. Name Sharing Scenario

Problem

User enters name in Home page.
Profile page should display the same name.

App.jsx

import React, { createContext, useState } from "react";
import { BrowserRouter, Routes, Route } from "react-router-dom";

import Home from "./components/Home";
import Profile from "./components/Profile";

export const UserContext = createContext();

function App() {
  const [user, setUser] = useState("");

  return (
    <UserContext.Provider value={{ user, setUser }}>
      <BrowserRouter>
        <Routes>
          <Route path="/" element={<Home />} />
          <Route path="/profile" element={<Profile />} />
        </Routes>
      </BrowserRouter>
    </UserContext.Provider>
  );
}

export default App;

Home.jsx

import React, { useContext } from "react";
import { UserContext } from "../App";

function Home() {

  const { user, setUser } = useContext(UserContext);

  return (
    <div>

      <input

        type="text"
        value={user}
        onChange={(e) => setUser(e.target.value)}
      />

    </div>
  );
}

export default Home;

Profile.jsx

import React, { useContext } from "react";
import { UserContext } from "../App";

function Profile() {

  const { user } = useContext(UserContext);

  return (
    <div>
      <h1>{user}</h1>
    </div>
  );
}

export default Profile;

4. Button Navigation Scenario

Problem

User clicks Next button in Home page and About page should open.

App.jsx

import React from "react";
import { BrowserRouter, Routes, Route } from "react-router-dom";

import Home from "./components/Home";
import About from "./components/About";

function App() {
  return (
    <BrowserRouter>
      <Routes>
        <Route path="/" element={<Home />} />
        <Route path="/about" element={<About />} />
      </Routes>
    </BrowserRouter>
  );
}

export default App;

Home.jsx

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

function Home() {

  const navigate = useNavigate();

  return (
    <div>

      <button onClick={() => navigate("/about")}>
        Next
      </button>

    </div>
  );
}

export default Home;

About.jsx

import React from "react";

function About() {
  return (
    <div>
      <h1>About Page</h1>
    </div>
  );
}

export default About;

5. Back Navigation Scenario

Problem

User opens Details page and clicks Back button to return previous page.

App.jsx

import React from "react";
import { BrowserRouter, Routes, Route } from "react-router-dom";

import Home from "./components/Home";
import Details from "./components/Details";

function App() {
  return (
    <BrowserRouter>
      <Routes>
        <Route path="/" element={<Home />} />
        <Route path="/details" element={<Details />} />
      </Routes>
    </BrowserRouter>
  );
}

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

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

return (

Home Page

  <button onClick={() => navigate("/details")}>
    Go To Details
  </button>
</div>

);
}

export default Home;

export default App;

jsx

Home.jsx

Details.jsx

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

function Details() {

  const navigate = useNavigate();

  return (
    <div>

      <button onClick={() => navigate(-1)}>
        Back
      </button>

    </div>
  );
}

export default Details;

Solving Train Station Problems Using Python While Loop

Athithya Sivasankarar — Thu, 28 May 2026 17:59:02 +0000

Problem Statement

We have two trains:

Train 1 stops at every 3rd station
Train 2 stops at every 5th station

We need to find:

First station where both trains meet
All stations where both trains meet
Total count of common stations
Last common station

We will check stations from 1 to 300.

1. First Station Where Both Trains Meet

station_no = 1

while station_no <= 300:

    if station_no % 3 == 0 and station_no % 5 == 0:
        print("First meeting station:", station_no)
        break

    station_no = station_no + 1

Output

First meeting station: 15

2. All Stations Where Both Trains Meet

station_no = 1

while station_no <= 300:

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

    station_no = station_no + 1

Some outputs:

3. Count of Common Stations

station_no = 1
count = 0

while station_no <= 300:

    if station_no % 3 == 0 and station_no % 5 == 0:
        count = count + 1

    station_no = station_no + 1

print("Total common stations:", count)

4. Last Common Station

station_no = 1
last_station = 0

while station_no <= 300:

    if station_no % 3 == 0 and station_no % 5 == 0:
        last_station = station_no

    station_no = station_no + 1

print("Last common station:", last_station)

BrowserRouter, Routes, Link, and useNavigate

Athithya Sivasankarar — Wed, 27 May 2026 18:12:02 +0000

What is React Router?

React Router is a library used for navigation in React applications.

It helps users move between pages without refreshing the browser.

To install React Router:

npm install react-router-dom

1. BrowserRouter

BrowserRouter is the main wrapper for routing.

It keeps your UI synchronized with the browser URL.

Example:

import {
  BrowserRouter,
  Routes,
  Route,
  Link
} from "react-router-dom";

function Home() {
  return <h1>Home Page</h1>;
}

function About() {
  return <h1>About Page</h1>;
}

function App() {

  return (
    <BrowserRouter>

      <nav>
        <Link to="/">Home</Link>


        <Link to="/about">About</Link>
      </nav>

      <Routes>
        <Route path="/" element={<Home />} />

        <Route path="/about" element={<About />} />
      </Routes>

    </BrowserRouter>
  );
}

export default App;

Why do we use BrowserRouter?

Without BrowserRouter, routing will not work.

It enables:

URL handling
Navigation
Route management

2. Routes and Route

Routes is used to group all routes.

Route defines which component should load for a specific URL.

Example:

import { Routes, Route } from "react-router-dom";

function Home() {
  return <h1>Home Page</h1>;
}

function About() {
  return <h1>About Page</h1>;
}

function App() {
  return (
    <Routes>
      <Route path="/" element={<Home />} />
      <Route path="/about" element={<About />} />
    </Routes>
  );
}

export default App;

Explanation
Path Component Loaded
/ Home
/about About

When users visit /about, React shows the About component.

3. Link

Normally, HTML uses tags for navigation.

But in React Router, we use Link.

Why?

Because reloads the page.
Link changes pages without refreshing.

Example:

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

function Navbar() {
  return (
    <div>
      <Link to="/">Home</Link>
      <br />

      <Link to="/about">About</Link>
    </div>
  );
}

export default Navbar;

Output
Clicking Home goes to Home page
Clicking About goes to About page
No page refresh happens

4. useNavigate Hook

useNavigateis used for programmatic navigation.

This means navigation happens using JavaScript code.

Example:

After login
After form submission
Redirecting users

Example:

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

function Login() {

  const navigate = useNavigate();

  function handleLogin() {
    alert("Login Successful");

    navigate("/home");
  }

  return (
    <div>
      <button onClick={handleLogin}>
        Login
      </button>
    </div>
  );
}

export default Login;

Explanation

When the button is clicked:

Alert message appears
User automatically moves to /home
Complete Example

import {
  BrowserRouter,
  Routes,
  Route,
  Link,
  useNavigate
} from "react-router-dom";

function Home() {
  return <h1>Home Page</h1>;
}

function About() {
  return <h1>About Page</h1>;
}

function Login() {

  const navigate = useNavigate();

  function loginUser() {
    navigate("/");
  }

  return (
    <button onClick={loginUser}>
      Go Home
    </button>
  );
}

function App() {

  return (
    <BrowserRouter>

      <Link to="/">Home</Link>
      <br />

      <Link to="/about">About</Link>

      <Routes>
        <Route path="/" element={<Home />} />
        <Route path="/about" element={<About />} />
        <Route path="/login" element={<Login />} />
      </Routes>

    </BrowserRouter>
  );
}

export default App;

Advantages of React Router
Fast navigation
No page refresh
Better user experience
Easy routing system
Works well for SPAs

Python Program to Double Flowers in Each Temple

Athithya Sivasankarar — Tue, 26 May 2026 17:49:18 +0000

Problem Statement

A devotee starts with 1 flower and visits 7 temples.
At each temple, the number of flowers doubles.

Write a Python program to find how many flowers the devotee has after visiting all 7 temples.

Program:

flowers = 1 temples_covered = 7 while temples_covered>0: temples_covered = temples_covered - 1 flowers = flowers * 2 print(flowers)

output:

DEV Community: Athithya Sivasankarar

Understanding Method Overriding in Java

Understanding Java Access Modifiers

Understanding Constructors and Constructor Overloading in Java

What is a Constructor?

Syntax

Why Do We Need Constructors?

Example 1: Default Constructor

Output

Explanation

Example 2: Constructor Initializing Variables

Output

Explanation

Types of Constructors

1. Default (No-Argument) Constructor

2. Parameterized Constructor

What is Constructor Overloading?

Example of Constructor Overloading

Output

How Constructor Overloading Works

Advantages of Constructor Overloading

Difference Between Constructors and Methods

Understanding the "this" Keyword in Java Using a SuperMarket Example

Static vs Non-Static in Java

What Does static Mean?

Example

What Does Non-Static Mean?

Example

Static vs Non-Static

A Simple Real-Life Example

Why Is main() Static?

Can a Static Method Access Non-Static Variables?

When Should We Use static?

Java Programming Language – Overview

useReducer in React

What is useReducer?

Syntax

Parameters

Returns

Example: Counter Application

Code

When Should You Use useReducer?

React Quiz App

Step 1: Create Context in App.jsx

App.jsx

Step 2: Create Home Page

Home.jsx

Step 3: Create Questions Data

questions.json

Step 4: Questions Component

Step 5: Result Page

Result.jsx

React useContext + useNavigate Scenarios

1. Login Scenario

Problem

App.jsx

Login.jsx

Dashboard.jsx

2. Logout Scenario

Problem

App.jsx

Login.jsx

Dashboard.jsx

3. Name Sharing Scenario

Problem

App.jsx

Home.jsx

Profile.jsx

4. Button Navigation Scenario

Problem

App.jsx

Home.jsx

About.jsx

5. Back Navigation Scenario

Problem

App.jsx

Home Page

Home.jsx

Details.jsx

Solving Train Station Problems Using Python While Loop

What Does `static` Mean?

Why Is `main()` Static?

When Should We Use `static`?