DEV Community: Deva I

Java Package and Import Example

Deva I — Thu, 09 Jul 2026 15:24:32 +0000

What is package

✓ A package in Java is a mechanism used to group related classes, interfaces and sub-packages together.

Key Benefits

Prevents Naming Conflicts: Two classes can have the same name if they live in different packages.
Easier Maintainability.
Better Access Control.

How to Create a Package

package chennai.south;
public class KoyambeduMarket
{
public static void main(String[] args)
{

}
public void buyVeg(){
System.out.println("Buy vegetables at low cost");
}
}

The class KoyambeduMarket created by package chennai and exist in sub package south.

├── KoyambeduMarket.java
└── chennai
└── south
└── KoyambeduMarket.class

package chennai.north;
public class KasimeduMarket
{
public static void main(String[] args){
}
public void buyFish(){
System.out.println("Buy fishes at low cost");
}
}

├── KasimeduMarket.java
└── chennai
├── north
│ └── KasimeduMarket.class
└── south
└── KoyambeduMarket.class

Import and how to call a method in differrent package

CODE EXAMPLE

package chennai.north;
import chennai.south.KoyambeduMarket;
public class Anna_Nagar
{
public static void main(String[] args){

KoyambeduMarket vegetables = new KoyambeduMarket();
vegetables.buyVeg();

KasimeduMarket fish = new KasimeduMarket();
fish.buyFish();
}
}

Java
├── Anna_Nagar.java
├── KoyambeduMarket.java
├── KasimeduMarket.java
└── chennai
├── north
│ ├── Anna_Nagar.class
│ └── KasimeduMarket.class
└── south
└── KoyambeduMarket.class

Working Flow of the code

STEP 1. Create Package :
package chennai.north;

STEP 2. Import statement :
import chennai.south.KoyambeduMarket;

✓ Because java dosen't know the KoyambeduMarket class its exist in sub-package south, its know the same sub-package classes only

Example its know the all classes existing in north,beacuse Anna_Nagar class existing innorth`.

✓ Java brings the KoyambeduMarket class from another package (chennai.south) into this file.

STEP 3. Create first object :
KoyambeduMarket vegetables = new KoyambeduMarket();

✓ Memory is allocated for a KoyambeduMarket object.

✓ Variable vegetables stores in the object.

STEP 4. Call the method :
vegetables.buyVeg();

✓ The buyVeg() method executes and prints the message
"Buy vegetables at low cost"

STEP 5. Create second object :
KasimeduMarket fish = new KasimeduMarket();

✓ A new KasimeduMarket object is created and variable fish stored in the object .

STEP 6. Call second method :
fish.buyFish();

✓ The buyFish() method executes and prints the message
"Buy fishes at low cost"

Output

Constructor Method and Constructor Overloading in Java

Deva I — Wed, 08 Jul 2026 15:45:55 +0000

Features of a Constructor

🔹 Automatically called when an object is created.

🔹 Has the same name as the class.(Instead of giving another name java consider it method and ask a return type)

🔹 Does not have a return type.

🔹 Used to initialize object specific values.

Types of Constructors

Default Constructor (Implicit)

🔹 If you do not write any constructor in your class, the Java compiler automatically inserts a blank, no-argument constructor during compilation.

🔹 This constructor keeps by Java virtual Machine.

2.No-Argument Constructor (Explicit)

🔹 A constructor written by the programmer with no parameters.

🔹 This constructor is created by user.

public MobilePhone(){
System.out.println("No arguments Constructor");
}

3.Parameterized Constructor

🔹 A constructor that accepts parameters to initialize objects with specific values.

public  MobilePhone(String name,int price,int battery){
this.name = name;
this.price = price;
this.battery = battery;
}

Constructor Overloading

🔹 Constructor overloading is the process of defining two or more constructors in the same class with different parameter lists.

🔹 The compiler decides which constructor to call, based on the number or type of arguments passed when creating an object.

public  MobilePhone(String name,int battery){
this.name = name;
this.battery = battery;
}

Code example

public class MobilePhone
{
String name;
int price;
int battery;

public MobilePhone(){
System.out.println("No arguments Constructor");
}

public  MobilePhone(String name,int price,int battery){
this.name = name;
this.price = price;
this.battery = battery;
}

public  MobilePhone(String name,int battery){
this.name = name;
this.battery = battery;
}

public static void main(String[] args)
{
   // No argument constructor
   MobilePhone brand = new MobilePhone();

   //Parameterized Constructor
   MobilePhone brand1 = new MobilePhone("Samsung s25 ultra",120000,5000);
   MobilePhone brand2 = new MobilePhone("Realmep4 power",28000,10000);

   //Constructor overloading(Two parameters)
   MobilePhone brand3 = new MobilePhone("Vivo t5x",7200);

   System.out.println("BrandName :" + brand1.name);
   System.out.println("Price :" + brand1.price);
   System.out.println("BrandName :" + brand2.name);
   System.out.println("Price :" + brand2.price);
   System.out.println("Battery :" + brand2.battery);
   System.out.println("BrandName :" + brand3.name);
   System.out.println("Battery :" + brand3.battery);
}
}

Output

Method Overloading in Java

Deva I — Tue, 07 Jul 2026 17:31:27 +0000

=> Method Overloading in Java allows a class to have same method name with different number of arguments or with type of arguments.

=> It is a core concept of oop used to achieve compile-time polymorphism.

=> Compile-time polymorphism means the Java compiler determines exactly which method to execute during compilation based on the method signature.

Code Example

public class Calculator
{
  public static void main(String[] args)
  {
  Calculator casio= new Calculator();
  casio.add(10,5);
  casio.add(1000);
  casio.add(3,3,3);
  casio.add(10.5f,9.5f);
  casio.add('a');
  }

   public void add(int i){
  System.out.println(i+500);

  }

  public void add(int i, int j){
  System.out.println(i+j);

  }

  public void add(int i, int j, int k){
  System.out.println(i*j*k);

  }

  public void add( float i, float j){
  System.out.println(i+j);

  }
}

3 Ways to Overload a Method

Number of parameters.
Data types of parameters.
Order of parameters.

Number of parameters: Having a different count of inputs.

 casio.add(10,5);
 casio.add(1000);
 casio.add(3,3,3);

// One integer and add 500

 public void add(int i){
  System.out.println(i+500);

  }


  // Add two integer, two different parameters

  public void add(int i, int j){
  System.out.println(i+j);

  }

  // Add three integers, three different parameters in one method 'add'

  public void add(int i, int j, int k){
  System.out.println(i*j*k);

  }

Data types of parameters: Having the same count but different variable types((e.g., int vs float)

casio.add(10.5f,9.5f);

public void add( float i, float j){
  System.out.println(i+j);

  }

widening conversion

 casio.add('a');

   public void add(int i){
  System.out.println(i+500);

  }

=> A char can be automatically type converted to an int.

=> The character 'a' has the Unicode/ASCII value = 97.

=> (i+500).i is 97+500 = 597.

Output

Java Program to Demonstrate Objects, Static and Non-static Variables and this Keyword

Deva I — Mon, 06 Jul 2026 18:09:10 +0000

◾ In the previous blog our problem is the Building class is to store 3 different students information in a single object.

◾ So, using the below method to overcome this problem.

CODE :

public class SuperMarket
{
static String Shopname = "Food India";
String name;
int price;
public static void main(String[] args)
{
SuperMarket product1= new SuperMarket();
product1.name = "Rice";
product1.price = 1500;

SuperMarket product2= new SuperMarket();
product2.name = "Eggs";
product2.price = 100;

SuperMarket product3= new SuperMarket();
product3.name = "Ice cream";
product3.price = 150;
product1.buy();
product2.buy();
product3.buy();

}
public void buy(){
System.out.println("Shop Name : " + Shopname);
System.out.println("Product   : " + this.name);
System.out.println("Price : " + price);

}
}

WORKING :

◾First create a class and I give the class name SuperMarket.

◾Then create static Variable, we need only one copy of this variable and all objects share the same Shopname Food India.

🔹Because all products are belongs to the same shop name.but the products have different names, So, use non-static variables for products names.

If all objects should share the same value => use a static variable.
If each object should have its own value => use an non-static variable.

🔹Every object should have its own values. so, create non-static variables like,

String name;
int price;

🔹This tells every SuperMarket object have a name and a price.

🔹Then, when we create objects, java automatically allocates space for each objects.

◾Next create a objects what count you want.I create 3 objects product1,product2 and product3.Example in the above program I take product1 object.

SuperMarket product1= new SuperMarket();

🔹The non-static variable allocate the space for each objects you create.

◾Then you assign your values,

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

◾The same process happens for product2 and product3

◾Then define the method to call the objects.

public void buy(){

}

In javascript we use the function for event or actions,to define function give function keyword.
In java give a method name diretly buy().
In java we give return method, its not compulsary in javascript to give a return method.
But, in java must give void, if you not return anything.

◾Then call the buy() method on inside the main block.if you call the method on the anywhere of program without main method, java dosen,t know that.

🔹Because, JVM only runs on main method.

🔹If you give buy()inside the main, while call the buy() method when main method called.

You call the any methods on main method.
But, you won't define or create methods inside the main method or any method you create.

◾Then print the products name and price use this

this refers to current object.

 System.out.println(this.name);

◾In this program price works without this.

System.out.println(price);

🔹Java automatically assumes the above line like System.out.println(this.price);

Using this is optional because this working on implicit from backround.
In non-static method this works on internally without giving it.
But in static not using this keyword because, this keyword refers to object.
Using class name for static methods.

System.out.println("Shop Name : " + Shopname);

🔹In this line Shopname is a static variable. but there is only one copy of Shopname, and it belongs to the class, not to any object.

🔹I give that line inside the buy() method.

public void buy() {
    System.out.println("Shop Name : " + Shopname);
}

◾Java looks for Shopname and finds it in the class.

🔹When the buy() method is called it prints the Shopname.

🔹In every time prints the Shopname name when the each buy() method calls, in this code buy() method called by 3 times. so, it prints Shopname 3 times.

If you give this.Shopname java give a error message.because thisrefers to the current object.

OUTPUT :

Static Variable vs Non-Static Variable(Instance Variable)

Deva I — Fri, 03 Jul 2026 06:58:26 +0000

Static Variable

Static refers to class specific information.
Declared using the static keyword.
It belongs to the Class.
Only one copy exists, shared by all objects.
Memory is allocated once when the class is loaded.
Accessed directly via the Class Name (ClassName.variable).
EX : The company name on an employee badge same for everyone.

Non-Static Variable(Instance Variable).

Non-Static refers to object specific information.
Declared without the static keyword.
Every object gets its own unique copy.
Memory is allocated every time a new object is created.
Requires an Object Reference (objectName.variable).
EX : The employee's specific name or ID number.

Example program

public class Building
{
static int age= 10;
static String name="Payilagam";


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

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

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

public static void main(String[] args)
{
Building student1= new Building();
Building student2= new Building();
Building student3= new Building();


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

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


}
}

=> In this program static variable using class name.because the static variable accessed by class name Building. `System.out.println(Building.name);

=> A static method cannot directly access non-static variables because those variables belong to objects.

=> If you give non-static variable using class name java give error like,
non-static variable studName2 cannot be referenced from a static context.

=> So, first create a object using new keyword like,
Building student1= new Building();

=> Then access the variable through that object.
System.out.println(student1.studName2);

=> student is the the object.
studName2 that object's value.

=> I created the three students information but, each object still contains all three students' information.

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

=> I use the same object name student1 to print all students information.because the student1,student2, and student3each object have all three students information.

=> Logically one object own one student information, not multiple students.

=> To overcome this problem using Constructor method.(TO BE DISCUSSED).

Output

Java Rules for creating a class, Data types and Static variable

Deva I — Thu, 02 Jul 2026 07:09:15 +0000

Rules for creating a class

=> Using class keyword to create a class.

public class Home
{

}

=> Give a class name meaningful (template).

=> Class name must start with Uppercase.

=> No special characters allowed except (_) underscore and ($) dollor symbol.

=> No space allowed inbetween class names.

Data types in java

Java data types define the type of data a variable can store in a program. They are categorized into two types

Primitive data types
Non primitive data types.

=> PRIMITIVE DATA TYPES : Store simple values directly in memory.It's categorized into two types Numeric and Non numeric type.

NUMERIC TYPE :

byte: 1 byte (8 bits). Range from -128 to 127. Used to save memory in large arrays.
short: 2 bytes (16 bits). Range from -32,768 to 32,767. Used for moderate numbers where memory is tight.
int: 4 bytes (32 bits). Range from -2.14 billion to 2.14 billion. This is the default type for whole numbers.
long: 8 bytes (64 bits). Extremely wide numerical range.
float: 4 bytes (32 bits). Sufficient for 6 to 7 decimal digits of precision.
double: 8 bytes (64 bits). Provides up to 15 decimal digits of precision. This is the default type for decimal numbers in Java.

NON NUMERIC TYPE

char: 2 bytes (16 bits). Stores a single character enclosed in single quotes (e.g., char grade = 'A';).
boolean: Stores only two possible values: true or false. Typically used for conditional flags and decision logic.

=> NON PRIMITIVE DATA TYPES: Store memory references to objects.

String: Represents an immutable sequence of characters enclosed in double quotes (e.g., String name = "Alice";).
Arrays: Collections of multiple elements of the data type grouped under a single name (e.g., int[] scores = {90, 85, 88};).
Classes: Custom user-defined blueprints that combine attributes (variables) and behaviors (methods) into unique entities.

Static variable :

=> In Java, when a variable is declared with the static keyword.

=> Then, a single variable is created and shared among all the objects at the class level.

=> Static variables are, essentially, global variables.

Key Characteristics :

Class-Level: We can create static variables at the class level only.
Accessed through Class Name: Static variables can be called directly with the help of a class only.
Single Copy: Every object of the class accesses and shares the exact same memory location.
Global Availability: Changes made to a static variable by one object are instantly visible to all other objects

public class Mobile
{
static int price = 23000;
static String name = "Vivo T5X 5g";

public static void main(String [] args){

System.out.println(Mobile.name);
System.out.println(Mobile.price);

}
}

OUTPUT :

Architecture of Backend Languages Java vs Node.js vs Python

Deva I — Fri, 26 Jun 2026 07:16:04 +0000

Architecture of Java

Java code compiles into platform-independent bytecode(class).

JDK (Java Development Kit)
Used for developing Java applications.
Contains JRE and development tools such as javac, javadoc, and jar.

This bytecode runs inside the Java Virtual Machine (JVM).

The JVM uses a Just-In-Time (JIT) compiler to turn bytecode into native machine code(binary code).

JRE (Java Runtime Environment)
Provides libraries and JVM required to run Java programs.The part of byte code convert into machine code is called JRE.

Source Code (.java)
        |
        v
   Java Compiler
      (javac)
        |
        v
 Bytecode (.class)
        |
        v
JVM(Java Virtual Machine)

        |
        v
  Machine Code
        |
        v
 Operating System
        |
        v
    Hardware

Architecture of Node js

Node.js using chrome v8 engine

=> The V8 Engine

Node.js is a runtime environment built on Google's V8 JavaScript Engine.

It compiles JavaScript code directly into native machine code.

=> Single Thread

Node.js uses a single main thread to process requests.

=> The Event Loop

The heart of Node.js.

Continuously checks for new events and executes callbacks.

=> Event Queue

Stores incoming requests and completed callbacks waiting to be processed.

=> Thread Pool (libuv)

Handles heavy tasks like:

File system operations
Database operations

=> Non-Blocking I/O

Node.js does not wait for one task to finish before processing another.

It can handle multiple requests simultaneously.


      Clients        
  (Browser, Mobile) 
          |
          v

     Event Queue 
          |
          v

     Event Loop 
          |
          v

     Thread Pool        
      (libuv) 
          |
          v

  Operating System        
   / File System      
    / Database

WORKING :

A client sends a request to the Node.js server.

The request enters the Event Queue.

The Event Loop picks up the request.

If the task is simple the Event Loop handles it directly.

If the task is I/O intensive, it is delegated to the Thread Pool managed by libuv.

Once the task is completed, a callback is placed back in the queue.

The Event Loop executes the callback and sends the response to the client.

Architecture of Python

Python using CPython Interpreter for execution.

The Interpreter: Python is an interpreted language. The source code is compiled into internal bytecode and then executed sequentially by the interpreter.

Unlike java python code doesn't need any explicit compilation(javac), its compile automatically by the interpreter.


Python Code (.py)
        |
        v
Compiler(Python Interpreter)
        |
        v
  Bytecode (.pyc)
        |
        v
Python Virtual Machine (PVM)
        |
        v
 Executes Bytecode
        |
        v
  Machine code
        |
        v
Operating System
        |
        v
     Hardware

Programming Paradigms

Deva I — Thu, 25 Jun 2026 07:04:14 +0000

what is programming paradigm

A programming paradigm is a method or style of solving problems using a programming language.

It provides a structured approach and set of principles that guide how programs are designed and implemented.

Different programming paradigms use different techniques and strategies.

A programming language may support one or more paradigms, allowing developers to choose the best approach based on project requirements.

Programming paradigms are two types :

Imperative Programming Paradigm
Declarative programming paradigm

Imperative Programming Paradigm

The imperative paradigm is centered on describing how a program operates. Code consists of step-by-step sequences of commands.

These contains three types, They are :

=> Procedural Programming: Organizes code into reusable blocks called routines, subroutines, or functions.

EXAMPLES : C, Coldfusion, pascal.

=> Object-Oriented Programming (OOP): Treats "objects" (which bundle both data and the behaviors that operate on that data) as the core building block. It focuses on concepts like inheritance, encapsulation, and polymorphism.

EXAMPLES : Java, c++, Python, Ruby.

=> Parallel processing approach: Parallel processing is the processing of program instructions by dividing them among multiple processors.

This is the oldest one and seems to be conquer.

Declarative Programming paradigm

The declarative paradigm focuses on what the final result should be, without explicitly detailing the step-by-step commands to get there.

These contains three types, They are :

=> Functional Programming: Treats computation as the evaluation of mathematical functions and avoids changing state or mutable data.

Programs emphasize pure functions that always return the same output for the same input.

Popular Languages: javascript, Haskell, Elixir, Lisp.

=> Logic Programming: Based on formal logic. You provide a set of facts and rules, and the system uses logical inferences to answer queries or solve problems.

Popular Languages: Prolog.

=> Data-driven / Query Languages: Allows developers to define the format of the data they need, letting the underlying engine handle retrieval.

Popular Languages: SQL.

Hybrid and Multi-Paradigm Approaches

Most modern languages are multi-paradigm. Languages like JavaScript, TypeScript, Python, and Rust allow developers to mix and match.

Object oriented programming(OOP) in Java

Deva I — Thu, 25 Jun 2026 06:29:12 +0000

What is object oriented programming :

Object-Oriented Programming (OOP) is a programming paradigm that organizes software around objects rather than functions and logic.

In simple words object-oriented programming is about creating objects that contain both data and methods.

OOP is faster and easier to execute.
OOP provides a clear structure for the programs.
Improves code reusability.
Enhances maintainability and scalability.
Makes programs easier to understand and manage.
Closely models real-world entities.

Concepts of Object-Oriented Programming (OOP)

Class- A blueprint or template for creating objects.

Object- An instance of class.

Inheritence- Reuse code from existing classes.

polymorphism- Allows the same method to behave differently.

Encapsulation- Protects data from direct access.

Abstraction- Hides unnecesssary details.

Class

A class is a blueprint or template used to create objects. It defines the properties (data) and behaviors (methods) that objects will have.

=> Contains data members and methods.
=> Does not occupy memory until an object is created.

EXAMPLE : A Car represents a class (blueprint), while BMW, Mercedes, and Audi represent objects (instances) created from that class.

Object

An object is an instance of a class. It represents a real-world entity and can access the properties and methods defined in the class.

=>Occupies memory when created.
=>Used to access class members.

Inheritence

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

=>Establishes parent-child relationship.
=>Supports method overriding.

EXAMPLE : Dog, Cat, Cow can be Derived Class of Animal.

Polymorphism
Encapsulation
Abstraction (To Be Discussed)

The major errors makes for beginners in simple java code

Deva I — Tue, 23 Jun 2026 17:49:49 +0000

=> Java, keywords and class names are case-sensitive.

=> Java keywords like (public, class, static, void) must be in lowercase.

Error 1

✓ public must be in lowercase because it's a keyword in java.

✓ Change public static Game instead of Public static Game

Error 2

✓ class is a valid Java keyword.

✓ Class is not the keyword for defining a class.

✓ class is a reserved keyword in Java and must written in lowercase.

Error 3

=> Java class names like (String, System, Scanner) usually start with an uppercase letter.

✓ Stringis a built in Java class, so the S must be uppercase.

Error 4

✓ System is also a built in java class, so the S must be uppercase.

Error 5

✓ In the line 5 end of printlnmissing a semicolan(;)

✓ Semicolan marks the end of a statement in java.

✓ Without semicolon (;) the statement not end.

Error 6

✓ In this code missing the curley braces { after the class declaration.

✓ Without the curley braces { java doesn't know where the class begin.

Error 7

✓ Missing dots(.) between system out println.

✓ without the dots,java cannot understand the relationship between system,out and println, and you'll get the compilation errors.

✓ Without the dots, java sees seperate words and doesn't know how they are connected.

✓ So write system.out.println instead of system out println

Error 8

✓ In this code error occurs in the main method parameter,because args is array of strings, not a single String.

✓Java store the values in array like,

args[0]="Hello"
args[1]="world"

✓If you not write (string[]args) your code will compile successfully,because String args is a valid method parameter.

✓ But,when you run the code you'll get the output what I got.

java Game

✓ So must write the public static void main(String[]args)

Correct Code

useCallback in react

Deva I — Tue, 16 Jun 2026 17:52:35 +0000

✓ The useCallback Hook is used to memoize a callback function.

✓ The useCallback function only re-executes when one of its dependencies changes value.

✓ The useCallback and useMemo Hooks are similar:

  ◾ useMemo returns a memoized value.

  ◾ useCallback returns a memoized function.

useReducer Scenario questions

Deva I — Mon, 15 Jun 2026 18:20:29 +0000

1. Counter with multiple actions :

CODE :

import { useReducer } from 'react'
import './App.css'

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: state.count = 0 }

        }

    }

    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>
        </div>

    )
}
export default App;

OUTPUT :

SCENARIO QUESTION :

Why is useReducer better than useState when multiple actions exist?

✓ useReducer centralizes all state update logic in one reducer function.

✓ Easy to manage multiple actions like INCREMENT, DECREMENT, RESET.

✓ Makes code more organized and scalable.

2. Login form state management :

A login form should manage username,password,error message and loading state.

CODE :

import React, { useReducer } from 'react'

function Login() {

    const initialState = {
        username: "",
        password: "",
        loading: false,
        error: "",
        isAuthenticated: false,
    };

    const LOGIN_START = "LOGIN_START";
    const LOGIN_SUCCESS = "LOGIN_SUCCESS";
    const LOGIN_ERROR = "LOGIN_ERROR";
    const LOGOUT = "LOGOUT";
    const SET_USERNAME = "SET_USERNAME";
    const SET_PASSWORD = "SET_PASSWORD";

    const loginReducer = (state, action) => {
        switch (action.type) {
            case LOGIN_START:
                return {
                    ...state,
                    loading: true,
                    error: "",

                };

            case LOGIN_SUCCESS:
                return {
                    ...state,
                    loading: false,
                    isAuthenticated: true,
                    error: "",
                };

            case SET_USERNAME:
                return {
                    ...state,
                    username: action.payload,
                };

            case SET_PASSWORD:
                return {
                    ...state,
                    password: action.payload,
                };

            case LOGIN_ERROR:
                return {
                    ...state,
                    loading: false,
                    error: action.payload,
                    isAuthenticated: false,
                };

            case LOGOUT:
                return {
                    ...state,
                    username: "",
                    password: "",
                    loading: false,
                    error: "",
                    isAuthenticated: false,
                };

            default:
                return state
        }
    }

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

    const LoginManagement = () => {
        dispatch({ type: LOGIN_START })

        setTimeout(() => {
            if (
                state.username === "Deva" &&
                state.password === "12345"
            ) {
                dispatch({ type: LOGIN_SUCCESS });
            } else {
                dispatch({
                    type: LOGIN_ERROR,
                    payload: "Invalid username or password",
                });
            }
        }, 1000);
    }

    return (
        <div>
            <h2>Login Form</h2>

            <input type="text" placeholder='Username' value={state.username} onChange={(e) => dispatch({ type: SET_USERNAME, payload: e.target.value })} />


            <input type="password" placeholder='Password' value={state.password} onChange={(e) => dispatch({ type: SET_PASSWORD, payload: e.target.value })} />
            <button onClick={LoginManagement}>Login</button>


            <button
                onClick={() => dispatch({ type: LOGOUT })}>Logout</button>

            {state.loading && <p>Loading...</p>}
            {state.error && <p>{state.error}</p>}
            {state.isAuthenticated && (<p>Login Successful</p>
            )}
        </div>
    )
}
export default Login;

OUTPUT :

SCENARIO QUESTION :

Why is useReducer suitable for complex state like a shopping cart?

✓ Shopping carts involve many actions:
• Add product
• Remove product
• Increase quantity
• Decrease quantity
• Clear cart

✓ useReducer keeps all cart logic in one place.

✓ Makes state updates predictable and easier to debug.

✓ Prevents complicated nested
Use stateupdates.

✓ Easier to maintain as the application grows.