Forem: Arun Kumar

Compile-Time and Runtime Exceptions

Arun Kumar — Tue, 31 Mar 2026 13:23:34 +0000

In Java, exceptions are mainly divided into two types:

Compile-Time Exceptions (Checked Exceptions)
Runtime Exceptions (Unchecked Exceptions)

What is a Compile-Time Exception?

A Compile-Time Exception (also called a Checked Exception) is an error that is detected during compilation.
The compiler checks these exceptions before the program runs.

Examples:

IOException
SQLException
FileNotFoundException

Example Program:
import java.io.*;

class Test {
    public static void main(String[] args) {
        FileReader file = new FileReader("test.txt"); // Compile-time error
    }
}

Correct Way:
import java.io.*;

class Test {
    public static void main(String[] args) {
        try {
            FileReader file = new FileReader("test.txt");
        } catch (FileNotFoundException e) {
            System.out.println("File not found");
        }
    }
}

What is a Runtime Exception?

A Runtime Exception (also called an Unchecked Exception) occurs while the program is running.

Examples:

ArithmeticException
NullPointerException
ArrayIndexOutOfBoundsException

Example Program:
class Test {
    public static void main(String[] args) {
        int a = 10;
        int b = 0;
        int result = a / b; // Runtime error
        System.out.println(result);
    }
}

Handling Runtime Exception:
class Test {
    public static void main(String[] args) {
        try {
            int a = 10;
            int b = 0;
            int result = a / b;
        } catch (ArithmeticException e) {
            System.out.println("Cannot divide by zero");
        }
    }
}

Java Exception Handling: Try, Catch & Common Exception Types

Arun Kumar — Mon, 30 Mar 2026 13:12:50 +0000

What is an Exception?

An exception is an unwanted or unexpected event that occurs during the execution of a program, disrupting the normal flow of instructions.

Example:

Dividing a number by zero
Accessing an invalid array index
Trying to open a file that doesn’t exist

Exception Hierarchy in Java

In Java, all exceptions are part of a class hierarchy.

Object
  └── Throwable
        ├── Exception
        │     ├── Checked Exceptions
        │     └── Unchecked Exceptions (RuntimeException)
        └── Error

Important Concept:
Every exception class in Java is either a direct or indirect child of the Exception class (except Error, which represents serious system issues).


##  Try-Catch Block

The `try-catch` block is used to handle exceptions.

###  Syntax:

java
try {
    // Code that may cause exception
} catch (ExceptionType e) {
    // Code to handle exception
}

Example:

public class Test {
    public static void main(String[] args) {
        try {
            int result = 10 / 0; // risky code
        } catch (Arithmetic Exception e) {
            System.out.println("Cannot divide by zero!");
        }
    }
}

Multiple Catch Blocks

You can handle different exceptions separately:

try {
    int arr[] = new int[3];
    arr[5] = 10;
} catch (ArrayIndexOutOfBoundsException e) {
    System.out.println("Index out of bounds!");
} catch (Exception e) {
    System.out.println("Some error occurred");
}

Finally Block

The finally block always executes, whether an exception occurs or not.

try {
    int data = 100 / 10;
} catch (Exception e) {
    System.out.println("Error");
} finally {
    System.out.println("Execution completed");
}

1️ ArithmeticException

Occurs when an illegal arithmetic operation is performed.

int x = 10 / 0;

2️NullPointerException

Occurs when trying to use a null reference.
java

String str = null;
System.out.println(str.length());

3️ ArrayIndexOutOfBoundsException

Occurs when accessing an invalid array index.

java

int arr[] = {1,2,3};
System.out.println(arr[5]);

Introduction to Java Exception Handling

Arun Kumar — Sat, 28 Mar 2026 19:11:40 +0000

What is Exception Handling?

Exception Handling in Java is a mechanism to handle runtime errors so that the normal flow of the program can be maintained.

An exception is an unwanted or unexpected event that occurs during program execution and disrupts the normal flow of instructions.

Why Exception Handling is Important?

Prevents program from crashing
Maintains normal flow of application
Helps in debugging errors easily

Basic Keywords in Exception Handling

try → block where code is written
catch → handles the exception

simple Example Program

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

        try {
            int a = 10;
            int b = 0;

            int result = a / b; // Exception occurs here

            System.out.println(result);
        } 
        catch (ArithmeticException e) {
            System.out.println("Cannot divide by zero");
        }
    }
}

# 🚀 Complete Guide to Log4j2 in Java (Beginner to Advanced)

Arun Kumar — Fri, 27 Mar 2026 10:51:04 +0000

Logging is one of the most important parts of any application. Without logs, debugging issues in production becomes extremely difficult. In Java, one of the most powerful and widely used logging frameworks is Log4j2.

This blog will help you understand Log4j2 from basics to practical usage in a Spring Boot project.

📌 What is Log4j2?

Log4j2 is a logging framework developed by Apache. It is used to record application events such as:

Application start/stop
Errors and exceptions
User activity
Debug information

👉 It is an improved version of Log4j (Log4j1).

⚡ Why Use Log4j2?

Log4j2 is preferred because it offers:

✔ High performance
✔ Flexible configuration (XML, JSON, YAML)
✔ Multiple output options (Console, File, Database)
✔ Different log levels
✔ Asynchronous logging support

📊 Log Levels in Log4j2

Log levels help categorize logs based on severity:

Level	Description
TRACE	Detailed debugging
DEBUG	Developer debugging
INFO	Normal application flow
WARN	Warning messages
ERROR	Something went wrong
FATAL	Critical failure

📦 How to Add Log4j2 in Spring Boot

Add this dependency in pom.xml:

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-log4j2</artifactId>
</dependency>

👉 This replaces default logging with Log4j2.

🧱 Basic Logger Example

import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;

public class Demo {
    private static final Logger logger = LogManager.getLogger(Demo.class);

    public static void main(String[] args) {
        logger.info("Application started");
        logger.error("Something went wrong");
    }
}

⚙️ Log4j2 Configuration (log4j2.xml)

Log4j2 uses a configuration file:

src/main/resources/log4j2.xml

🖥️ Console Logging

<Console name="Console" target="SYSTEM_OUT">
    <PatternLayout pattern="%d{yyyy-MM-dd HH:mm:ss} %-5level %logger - %msg%n"/>
</Console>

👉 Prints logs in terminal

📁 File Logging

<RollingFile name="FileLogger"
             fileName="logs/app.log"
             filePattern="logs/app-%d{yyyy-MM-dd}.log">
    <PatternLayout pattern="%d{yyyy-MM-dd HH:mm:ss} %-5p %c - %m%n"/>
</RollingFile>

👉 Stores logs in files with daily rotation

🗄️ Database Logging (Advanced)

<JDBC name="DatabaseAppender" tableName="logs">
    <DriverManager 
        connectionString="jdbc:postgresql://localhost:5432/arundb"
        userName="postgres"
        password="password"/>

    <ColumnMapping name="log_date" type="java.sql.Timestamp"/>
    <ColumnMapping name="level" pattern="%level"/>
    <ColumnMapping name="logger" pattern="%logger"/>
    <ColumnMapping name="message" pattern="%message"/>
</JDBC>

👉 Saves logs directly into database

🔗 Connecting Appenders

<Root level="info">
    <AppenderRef ref="Console"/>
    <AppenderRef ref="FileLogger"/>
    <AppenderRef ref="DatabaseAppender"/>
</Root>

👉 Sends logs to multiple destinations

🔄 Logging Flow

Application → Logger → Appenders → Output (Console/File/DB)

🧪 Example in Spring Boot Controller

@RestController
public class UserController {

    private static final Logger logger = LogManager.getLogger(UserController.class);

    @GetMapping("/test")
    public String test() {
        logger.info("API called");
        return "Success";
    }
}

# Complete Guide to Java String Methods (Simple Blog)

Arun Kumar — Wed, 25 Mar 2026 17:29:47 +0000

📌 Introduction

In Java, a String is one of the most commonly used classes. It represents a sequence of characters. Java provides many built-in methods to perform operations like searching, modifying, comparing, and formatting strings.

🔹 1. Creating a String

String s1 = "Hello";
String s2 = new String("World");

🔹 2. Length of String

String str = "Java";
System.out.println(str.length());  // 4

🔹 3. Convert Case

String str = "java";

System.out.println(str.toUpperCase()); // JAVA
System.out.println(str.toLowerCase()); // java

🔹 4. Character Access

String str = "Java";

System.out.println(str.charAt(0)); // J

🔹 5. Compare Strings

String a = "Java";
String b = "java";

System.out.println(a.equals(b));         // false
System.out.println(a.equalsIgnoreCase(b)); // true

🔹 6. Compare Using compareTo()

String a = "apple";
String b = "banana";

System.out.println(a.compareTo(b)); // negative value

🔹 7. Substring

String str = "HelloWorld";

System.out.println(str.substring(0, 5)); // Hello

🔹 8. Contains

String str = "Java Programming";

System.out.println(str.contains("Java")); // true

🔹 9. StartsWith / EndsWith

String str = "Java Programming";

System.out.println(str.startsWith("Java")); // true
System.out.println(str.endsWith("ing"));    // true

🔹 10. Index Methods

String str = "banana";

System.out.println(str.indexOf('a'));     // 1
System.out.println(str.lastIndexOf('a')); // 5

🔹 11. Replace

String str = "Java";

System.out.println(str.replace('a', 'o')); // Jovo

🔹 12. Trim

String str = "  Hello  ";

System.out.println(str.trim()); // "Hello"

🔹 13. Split

String str = "Java,Python,C++";

String[] arr = str.split(",");

for (String s : arr) {
    System.out.println(s);
}

🔹 14. Join

String result = String.join("-", "Java", "Python", "C++");

System.out.println(result); // Java-Python-C++

🔹 15. Concatenation

String a = "Hello";
String b = "World";

System.out.println(a + " " + b); // Hello World
System.out.println(a.concat(b)); // HelloWorld

🔹 16. isEmpty() and isBlank()

String s1 = "";
String s2 = " ";

System.out.println(s1.isEmpty()); // true
System.out.println(s2.isBlank()); // true

🔹 17. toCharArray()

String str = "Java";

char[] arr = str.toCharArray();

for (char c : arr) {
    System.out.println(c);
}

🔹 18. Value Conversion

int num = 100;

String str = String.valueOf(num);
System.out.println(str); // "100"

🔹 19. Intern Method

String s1 = new String("Java");
String s2 = s1.intern();

System.out.println(s1 == s2); // false

🔹 20. Format

String name = "Arun";
int age = 25;

String result = String.format("Name: %s, Age: %d", name, age);
System.out.println(result);

🎯 Important Points

Strings are immutable (cannot be changed)
Every operation creates a new object
Use StringBuilder for better performance in loops

✅ Practice Ideas

Reverse a string
Check palindrome
Count vowels
Remove duplicates

java packages introduction

Arun Kumar — Thu, 26 Feb 2026 08:00:19 +0000

A package in Java is used to group related classes. Think of it as a folder in a file directory. We use packages to avoid name conflicts, and to write a better maintainable code. Packages are divided into two categories:

Built-in Packages (packages from the Java API)
User-defined Packages (create your own packages)

Built-in Packages

The Java API is a library of prewritten classes, that are free to use, included in the Java Development Environment.

The library contains components for managing input, database programming, and much much more. The complete list can be found at Oracles website: https://docs.oracle.com/javase/8/docs/api/.

The library is divided into packages and classes. Meaning you can either import a single class (along with its methods and attributes), or a whole package that contain all the classes that belong to the specified package.

To use a class or a package from the library, you need to use the import keyword:
Syntax :

import package.name.Class; // Import a single class
import package.name.*; // Import
Import a Class :

If you find a class you want to use, for example, the Scanner class, which is used to get user input, write the following code:
Example :

import java.util.Scanner;

the example above, java.util is a package, while Scanner is a class of the java.util package.

To use the Scanner class, create an object of the class and use any of the available methods found in the Scanner class documentation. In our example, we will use the nextLine() method, which is used to read a complete line:
Example :

import java.util.Scanner;

class MyClass {
public static void main(String[] args) {
Scanner myObj = new Scanner(System.in);
System.out.println("Enter username");

String userName = myObj.nextLine();
System.out.println("Username is: " + userName);

}
}

Import a Package :

There are many packages to choose from. In the previous example, we used the Scanner class from the java.util package. This package also contains date and time facilities, random-number generator and other utility classes.

To import a whole package, end the sentence with an asterisk sign (*). The following example will import ALL the classes in the java.util package:
Example:


import java.util.*;

User-defined Packages :

To create your own package, you need to understand that Java uses a file system directory to store them. Just like folders on your computer:

Data Types in Java

Arun Kumar — Tue, 10 Feb 2026 07:28:24 +0000

Data Types in Java

Data types specify the different sizes and values that can be stored in the variable. There are two types of data types in Java:

Primitive data types: The primitive data types include boolean, char, byte, short, int, long, float and double.
Non-primitive data types: The non-primitive data types include Classes, Interfaces, String and Arrays. Java is a statically-typed programming language. It means, all variables must be declared before its use. That is why we need to declare variable's type and name. We have to explicitly declare variable before it use.

_
Primitive Data Types:_
These are predefined by the language and represent basic values. There are eight primitive data types in Java:

byte: 8-bit signed integer. Range: -128 to 127.
short: 16-bit signed integer. Range: -32,768 to 32,767.
int: 32-bit signed integer. Range: -2,147,483,648 to 2,147,483,647.
long: 64-bit signed integer. Range: -9,223,372,036,854,775,808 to 9,223,372,036,854,775,807.
float: 32-bit single-precision floating-point number.
double: 64-bit double-precision floating-point number.
boolean: Represents true or false values.
char:16 bit unicode character

_
Non-Primitive (Reference) Data Types:_
These types are created by the programmer and store references to objects in memory. Examples of non-primitive data types include:


Classes: Templates for creating objects.
Interfaces: Contracts that define methods for classes.
Arrays: Collections of elements of the same data type.
String: Represents a sequence of characters.

Primitive vs Non-Primitive Data Types
Primitive data types:

Memory: stored in stack
Speed: Primitive data types are faster
Example: int a=10;

Non-Primitive Data Types:

Memory: stored in heap
Speed: Non-Primitive data types are slower
Example: String name="aaa";

Java features

Arun Kumar — Wed, 04 Feb 2026 17:45:52 +0000

Java is one of the most widely used programming languages in the world.
It is object-oriented, platform-independent, and secure, making it a top choice for web, mobile, and enterprise applications.
Let’s explore the main features of Java that make it so powerful object oriented programming language

Simple Syntax
Object-Oriented
Platform Independent
Interpreted
Scalable
Portable
Secured and Robust
Memory Management
High Performance
Multithreading
Rich Standard Library
Functional Programming Features
Integration with Other Technologies
Support for Mobile and Web Application
Documentation and Community Support

1. 1.Simple Syntax

Java syntax is very straightforward and very easy to learn. Java removes complex features like pointers and multiple inheritance, which makes it a good choice for beginners.

2.Object-Oriented

Java follows Object-Oriented Programming (OOP) principles. Everything is treated as an object, which makes the code modular, reusable, and maintainable. Key OOP concepts in Java include Encapsulation, Inheritance, Polymorphism, and Abstraction

3. Platform Independent

Java follows the principle “Write Once, Run Anywhere” (WORA).
Compiled Java code becomes bytecode, which can run on any operating system with a Java Virtual Machine (JVM), making it highly portable

4.Interpreted

Java code is not directly executed by the computer. It is first compiled into bytecode. This byte code is then understand by the JVM. This enables Java to run on any platform without rewriting code.

5.Scalable

Java can handle both small and large-scale applications. Java provides features like multithreading and distributed computing.
It allows developers to add more features or handle more users without changing the core architecture.

6.Portable

Java Programs can run on any platform without modification.
After compilation, Java produces bytecode (.class files) instead of machine-specific code.
The Java Virtual Machine (JVM) on any system can execute this bytecode, making Java programs highly portable across different operating systems like Windows, macOS, or Linux

7.Secured and Robust

Java is secure because it prevents unauthorized access and ensures safe execution, and it is robust because it handles errors efficiently and manages memory automatically

8. Memory Management

Java provides automatic memory management, which makes programs more reliable and reduces memory leaks.
It has a Garbage Collector (GC) that automatically removes unused objects from memory.
Makes applications more robust and efficient.

9. High Performance

Java provides high performance because the JIT compiler converts bytecode into native code at runtime, and its memory and thread management optimize execution speed.

10. Multithreading

Java supports multithreading, which means it can run multiple tasks simultaneously within a single program.
Each thread runs independently, allowing better CPU utilization and faster execution.
Useful in applications like animations, gaming, file downloads, and handling multiple user requests in web servers.
Java provides built-in support for multithreading through the Thread class and Runnable interface.

11. Rich Standard Library

Java provides various pre-built tools and libraries which is known as Java API.
These libraries cover areas like data structures, networking, file I/O, database access, utilities, GUI,database connectivity (JDBC)
and more.
Developers can reuse pre-written code, which speeds up development and reduces errors.
Popular packages include java.lang, java.util, java.io, java.net, and javax.swing.

12. Functional Programming Features

Java supports functional programming concepts starting from Java 8, making code more concise and readable.
Features include lambda expressions, streams, and functional interfaces.
These allow developers to write declarative code, perform operations on collections easily, and enable parallel processing.
Functional programming helps in reducing boilerplate code and improves productivity

13. Documentation and Community Support

Java has extensive documentation and a large global community, which makes learning and problem-solving much easier.
The official Java API documentation provides detailed explanations of classes, methods, and packages.
A strong developer community contributes tutorials, libraries, frameworks, and answers on platforms like Stack Overflow, GitHub, and forums.
This support helps developers quickly resolve issues, stay updated, and adopt best practices.

Java Architecture: JDK, JRE, JVM, and JIT!

Arun Kumar — Mon, 02 Feb 2026 19:56:13 +0000

Before learning Java, it is essential to understand how the Java process is carried out. I will explain them in simple language based on my understanding while learning Java.

What is JDK (JAVA Development Kit)?

It will help us to write and develop Java programs.

Whenever you write a program and try to compile it. This contains Java Compiler (javac), which checks for any syntax errors, and provides you with the error message along with the line number.

If the program doesn't have any errors, then it converts the .java file to a .class file. This way, you understand our program doesn't have any errors.

What is JRE (Java Runtime Environment)?

It is required to run Java applications. It takes the compiled .class file, and it helps to execute the program in the system.

It provides core libraries that are required while the program is running.

WHAT IS JVM (JAVA VIRTUAL MACHINE)

-This plays a major role in the process, where it converts the bytecode into machine code.

Manages memory (Heap & Stack)

Execute the program, and this is why Java is a platform-independent, meaning write once, run anywhere(WORA)

JIT(JUST IN TIME COMPILER)?

It is the JVM's Execution Engine. Converts byte code into machine code at run time.

Improves performance and makes Java programs run faster

Interpreter runs code line by line, but JIT compiles frequently used code for speed

Understanding the differences between these helped me clearly see how Java programs are developed and executed. As a beginner, learning these basics gives me confidence to move forward with core Java concepts.

REACT USESTATE

Arun Kumar — Sun, 25 Jan 2026 04:41:05 +0000

Understanding useState in `React`

React is a powerful library for building user interfaces, and one of its most important features is the ability to manage state. In function components, state management is typically done using the useState hook. In this section, we’ll dive into what useState is, how to use it, and provide a complete example of a counter app built with React.

What is `useState`?

useState is a Hook that lets you add React state to function components. It allows you to store and update values that can change over time. When the state changes, React re-renders the component to reflect the updated state.

Syntax of `useState`

The useState hook is simple to use. It takes one argument, the initial state, and returns an array containing two elements:

The current state value: This is the current value of the state.
A function to update the state: This function is used to update the state value whenever necessary.

Here is the basic syntax:

const [state, setState] = useState(initialState);

state: The current state value.
setState: The function to update the state.
initialState: The initial value of the state. This can be any data type—string, number, array, object, etc.

What is React? why should learn React?

Arun Kumar — Fri, 23 Jan 2026 04:27:53 +0000

React.js is a popular JavaScript library for building modern, dynamic, and high-performance user interfaces (UI). It was developed by Facebook (now Meta) in 2013 and has since become the most widely used frontend library in the world.

One of React’s core strengths is its component-based architecture, which allows developers to break down the UI into reusable, manageable components. This leads to cleaner, more scalable code.

✨ Why Learn React.js?

React offers several advantages that make it a top choice for frontend development:

✅ Fast, Dynamic, and Interactive UI: React utilizes a virtual DOM to efficiently update only the parts of the UI that have changed.
✅ Build Single Page Applications (SPAs): Create seamless, fast-loading web apps that feel like native applications.
✅ Cross-Platform App Development with React Native: Use the same skills to build both web and mobile apps.
✅ High Demand in Job & Freelance Markets: React developers are in huge demand across freelancing platforms and tech companies.
✅ Perfect Fit with Backend APIs: Easily connect React to REST APIs built with Node.js, Django, Flask, or FastAPI.

🔥 Why React.js is Essential to Learn in 2025

1.## Most In-Demand Frontend Skill
React continues to top the charts in JavaScript framework rankings. Tech giants like Google, Facebook, Netflix, Airbnb, and Instagram all rely on React in production.

2. High Salary Opportunities

React developers command high salaries — even 6-figure USD salaries are common in the USA, Europe, or remote-first companies.

3. One Codebase for Web & Mobile

With React Native, you can use the same JavaScript and React knowledge to build native mobile apps for both Android and iOS.

4. Perfect Match with Backend Technologies

React works flawlessly with any backend — whether it’s Node.js, Django REST Framework, or FastAPI — making it ideal for full-stack development.

5. Dominates Freelancing Platforms

On Fiverr, Upwork, and Freelancer, React is one of the most requested skills for web application projects.

👨‍💻 Career Opportunities as a React.js Developer

Whether you want to freelance or land a full-time role, here are some paths React.js can lead you to:

Frontend Developer — Work in product-based or SaaS companies
Full-Stack Developer — MERN (MongoDB, Express, React, Node), PERN, or DJR (Django + React)
Mobile App Developer — With React Native
UI/UX-Oriented Web Developer
Freelance Web Application Specialist
JAMstack Developer — Combine React with Headless CMS (e.g., Contentful, Strapi)

📘 Where to Start? Recommended Learning Resources

📚 Books:
The Road to React — Robin Wieruch
Learning React — Alex Banks & Eve Porcello
Fullstack React — Anthony Accomazzo

🎓 Online Courses:

freeCodeCamp — React Full Course
Udemy — React — The Complete Guide by Maximilian Schwarzmüller
Scrimba — Learn React for Free

🎥 YouTube Channels:

Learn with Sumit — One of the best React playlists in Bangla
Codevolution, The Net Ninja, Traversy Media — Great React tutorials in English

📌 Sources:

ReactJS Official Documentation
GitHub Stars & Trends
Stack Overflow & Developer Surveys
ChatGPT research synthesis

React.js isn’t just a trend — it’s a career-changing skill. Whether you’re building complex applications, starting freelancing, or diving into full-stack development, React is the key to unlocking those doors in 2025.

Get , Post, Put, Delete in Axios

Arun Kumar — Tue, 16 Dec 2025 13:13:14 +0000

Axios is a promise-based HTTP Client for node.js and the browser. It has an isomorphic shape ( it can run in the browser and nodejs with the same codebase). It uses the native node.js http module on the server, and XMLHttpRequests on the client (browser).

Installation

Using npm

npm install axios

Using bower

bower install axios

Using yarn

yarn add axios

Check my earlier article on building a React app :

Let's add the axios package to our js code now.

import axios from 'axios';

The Fundamentals of Axios
GET Request

axios.get('url')
  .then((response) => {
    // handle success
    console.log(response);
  })
  .catch((error)=> {
    // handle error
    console.log(error);
  })

POST Request

axios.post('url', {
id : 1,
name : 'rohith'
})
  .then((response) => {
    // handle success
    console.log(response);
  })
  .catch((error)=> {
    // handle error
    console.log(error);
  })

PUT Request

axios.put('url', {
id : 1,
name : 'ndrohith'
})
  .then((response) => {
    // handle success
    console.log(response);
  })
  .catch((error)=> {
    // handle error
    console.log(error);
  })

DELETE Request

axios.delete('url', {
id : 1,
})
  .then((response) => {
    // handle success
    console.log(response);
  })
  .catch((error)=> {
    // handle error
    console.log(error);
  })

Using Axios in React Class

import axios from "axios";
class AxiosRequests extends Component {
  constructor(props) {
    super(props);
    this.state = {};
  }

  async componentDidMount() {
    try {
      await axios({
        url: url,
        method: "GET",
      }).then((res) => {
        // handle success
        console.log(res);
      });
    } catch (e) {
      // handle error
      console.error(e);
    }
  }

  postData = async (e) => {
    e.preventDefault();
    var data = {
      id: 1,
      name: "rohith",
    };
    try {
      await axios({
        url: url,
        method: "POST",
        data: data,
      }).then((res) => {
        // handle success
        console.log(res);
      });
    } catch (e) {
      // handle error
      console.error(e);
    }
  };

  putData = async (e) => {
    e.preventDefault();
    var data = {
      id: 1,
      name: "ndrohith",
    };
    try {
      await axios({
        url: url,
        method: "PUT",
        data: data,
      }).then((res) => {
        // handle success
        console.log(res);
      });
    } catch (e) {
      // handle error
      console.error(e);
    }
  };

  deleteData = async (e) => {
    e.preventDefault();
    var data = {
      id: 1,
    };
    try {
      await axios({
        url: url,
        method: "DELETE",
        data: data,
      }).then((res) => {
        // handle success
        console.log(res);
      });
    } catch (e) {
      // handle error
      console.error(e);
    }
  };

  render() {
    return <></>;
  }
}

export default AxiosRequests;

NOTE: async/await is a feature of ECMAScript 2017 that is not supported by Internet Explorer and previous browsers, therefore use with caution.

REFERENCE : https://axios-http.com/docs/intro

Forem: Arun Kumar

Compile-Time and Runtime Exceptions

What is a Runtime Exception?

Examples:

Java Exception Handling: Try, Catch & Common Exception Types

What is an Exception?

Exception Hierarchy in Java

Multiple Catch Blocks

Finally Block

1️ ArithmeticException

2️NullPointerException

3️ ArrayIndexOutOfBoundsException

Introduction to Java Exception Handling

What is Exception Handling?

Why Exception Handling is Important?

Basic Keywords in Exception Handling

simple Example Program

# 🚀 Complete Guide to Log4j2 in Java (Beginner to Advanced)

📌 What is Log4j2?

⚡ Why Use Log4j2?

📊 Log Levels in Log4j2

📦 How to Add Log4j2 in Spring Boot

🧱 Basic Logger Example

⚙️ Log4j2 Configuration (log4j2.xml)

🖥️ Console Logging

📁 File Logging

🗄️ Database Logging (Advanced)

🔗 Connecting Appenders

🔄 Logging Flow

🧪 Example in Spring Boot Controller

# Complete Guide to Java String Methods (Simple Blog)

📌 Introduction

🔹 1. Creating a String

🔹 2. Length of String

🔹 3. Convert Case

🔹 4. Character Access

🔹 5. Compare Strings

🔹 6. Compare Using compareTo()

🔹 7. Substring

🔹 8. Contains

🔹 9. StartsWith / EndsWith

🔹 10. Index Methods

🔹 11. Replace

🔹 12. Trim

🔹 13. Split

🔹 14. Join

🔹 15. Concatenation

🔹 16. isEmpty() and isBlank()

🔹 17. toCharArray()

🔹 18. Value Conversion

🔹 19. Intern Method

🔹 20. Format

🎯 Important Points

✅ Practice Ideas

java packages introduction

Built-in Packages

User-defined Packages :

Data Types in Java

Data Types in Java

Java features

1. 1.Simple Syntax

2.Object-Oriented

3. Platform Independent

4.Interpreted

5.Scalable

6.Portable

7.Secured and Robust

8. Memory Management

9. High Performance

10. Multithreading

11. Rich Standard Library

12. Functional Programming Features

13. Documentation and Community Support

Java Architecture: JDK, JRE, JVM, and JIT!

What is JDK (JAVA Development Kit)?

What is JRE (Java Runtime Environment)?

WHAT IS JVM (JAVA VIRTUAL MACHINE)

JIT(JUST IN TIME COMPILER)?

REACT USESTATE

Understanding useState in React

Understanding useState in `React`

What is `useState`?

Syntax of `useState`