Forem: Bhuvana Sri R

Features of Java

Bhuvana Sri R — Sat, 08 Nov 2025 06:16:33 +0000

Java, a widely used programming language, possesses a range of features that contribute to its popularity and versatility. Key features include:

Object-Oriented: Java is a fundamentally object-oriented language, leveraging concepts like classes, objects, inheritance, polymorphism, encapsulation, and abstraction to structure code and promote reusability and modularity.
Platform Independent: This is a cornerstone feature, often summarized by "Write Once, Run Anywhere." Java code is compiled into bytecode, which can then be executed on any system equipped with a Java Virtual Machine (JVM), regardless of the underlying operating system or hardware architecture.
Simple: Java's syntax is designed to be relatively straightforward and easy to learn, particularly for those familiar with C/C++. It omits complex features like explicit pointers and operator overloading to enhance simplicity.
Secure: Java incorporates robust security features, including a bytecode verifier, automatic memory management (garbage collection), and the absence of explicit pointers, which collectively contribute to secure application development and execution.
Robust: Java emphasizes reliability and error handling. It employs strong type checking, exception handling mechanisms, and automatic garbage collection to prevent common programming errors and enhance application stability.
Multithreaded: Java natively supports multithreading, allowing programs to execute multiple parts concurrently. This feature is crucial for developing interactive and responsive applications, especially in areas like GUI development and server-side programming.
High Performance: While Java is an interpreted language, its use of Just-In-Time (JIT) compilation converts bytecode into native machine code at runtime, significantly improving performance compared to purely interpreted languages.
Distributed: Java's networking capabilities and support for technologies like Remote Method Invocation (RMI) facilitate the creation of distributed applications that can communicate and interact across networks.
Dynamic: Java is designed to be dynamic, capable of loading classes and linking them dynamically at runtime. This flexibility allows for dynamic updates and extensions to applications.
Portable: Closely related to platform independence, Java's portability means that compiled Java programs can be easily moved and executed across different environments without requiring modifications.

DataTypes in Java

Bhuvana Sri R — Thu, 16 Oct 2025 07:08:22 +0000

What is a Data Type?

A data type in Java defines the type of data a variable can store. It tells the compiler whether the variable will hold a number, a character, true/false, or an object.

Two Types of Data Types :

Primitive DataType
Non-Primitive DataType

Primitive DataType:

Primitive data types are the basic, built-in types in Java used to store simple values like numbers, characters, and true/false.

The 8 primitive types are:

- byte – small integers
- short – medium integers
- int – large integers
- long – very large integers
- float – decimal numbers (less precise)
- double – decimal numbers (more precise)
- char – single character
- boolean – true or false

Non-Primitive DataType

Non-primitive data types, also called reference types, are types derived from classes. They are used to store objects or more complex data rather than simple values.

Examples:

String → stores text
Arrays → stores multiple values of the same type
Classes and Objects → store user-defined data
Interface → defines a contract for classes

Java

Bhuvana Sri R — Thu, 16 Oct 2025 06:42:38 +0000

1. What is Java?

Java is a high-level, object-oriented, and platform-independent programming language. It is widely used for developing web, mobile, and enterprise applications because it’s reliable, secure, and runs on any platform without modification.
It also has strong community support and is used in many real-world applications, including Android development. Learning Java helps me build a strong foundation in object-oriented programming concepts and prepares me for various software development roles.

2. Why do you prefer Java over other languages?

I prefer Java because it’s simple, secure, and platform-independent.
It’s widely used in real-world projects like web and Android development, and it helps me build a strong foundation in object-oriented programming.

3.Where is Java used?

Java is used in web applications, mobile apps (especially Android), desktop software, enterprise systems, cloud applications, and IoT devices.
It’s popular because it works on any platform and is used by many large companies worldwide.

4.What is the main feature of Java?

The main feature of Java is that it is platform-independent — meaning you can “write once and run anywhere.”
This is possible because of the Java Virtual Machine (JVM), which allows Java programs to run on any operating system.

Types of Error in Java

Bhuvana Sri R — Wed, 15 Oct 2025 05:24:45 +0000

In Java, errors are problems that occur during the execution or compilation of a program. They can be broadly categorized into three main types:

Compile-time Errors

These errors occur when you try to compile the program — before it runs.
They are usually syntax or semantic errors detected by the Java compiler (javac).

Examples:

Missing semicolon (;)
Using an undeclared variable
Misspelling a keyword
Type mismatch

Example Code:

public class Example {
    public static void main(String[] args) {
        int a = 5
        System.out.println(a);
    }
}

Error: Missing semicolon (;) → Compile-time error

Runtime Errors

These occur while the program is running, after successful compilation.
They cause the program to crash or behave unexpectedly.

Examples:

Dividing by zero → ArithmeticException
Accessing invalid array index → ArrayIndexOutOfBoundsException
Null object access → NullPointerException
File not found → FileNotFoundException

Example Code:

public class Example {
    public static void main(String[] args) {
        int a = 10 / 0;
        System.out.println(a);
    }
}

Error: ArithmeticException: / by zero → Runtime error

Logical Errors

These occur when the program runs successfully but produces the wrong output.
The compiler and runtime won’t catch them — they are human mistakes in logic.

Examples:

Using the wrong formula
Incorrect loop conditions
Wrong variable used in calculation

Example Code:

public class Example {
    public static void main(String[] args) {
        int a = 10, b = 5;
        System.out.println("Sum = " + (a - b)); // Logical mistake
    }
}

Output: Sum = 5 → Incorrect result due to logic error

React Question

Bhuvana Sri R — Mon, 06 Oct 2025 04:11:53 +0000

1)What is the difference between a functional component and a class component in React?

A functional component in React is a simple JavaScript function that returns JSX and uses Hooks like useState or useEffect for state and lifecycle management. It’s easy to read and faster to write.
A class component is the older way of building components using the ‘class’ keyword. It uses a render method and the ‘this’ keyword to show data.
Functional components are now preferred because they make the code cleaner, simpler, and more efficient.

2)How does JSX work internally? Why do we need it instead of plain JavaScript?

JSX stands for JavaScript XML. It allows us to write HTML-like code inside JavaScript, which makes the code easier to read and write. Internally, JSX doesn’t run directly in the browser — it’s converted by tools like Babel into normal JavaScript code using React’s createElement() function.
We use JSX instead of plain JavaScript because it makes code easier to read, write, and maintain. Without JSX, we’d have to write long and complex JavaScript code for every element, which is harder to manage. So, JSX helps developers build user interfaces faster and more clearly.

3)What is Virtual DOM and how does React use it for rendering?

The Virtual DOM is a lightweight copy of the real DOM. When something changes in a component, React updates the Virtual DOM first, compares it with the previous version, and then updates only the parts that actually changed in the real DOM. This makes rendering faster and more efficient.

4)Explain props vs state with an example.

Props are used to pass data from a parent component to a child component and are read-only, meaning the child can’t change them.
State is data that is managed inside a component and can change over time, causing the component to re-render.

5)What is lifting state up in React? Give an example.
//(To Be Disscussed)
Lifting state up means moving a shared state to the closest common parent component so that multiple child components can access and update it through props.

6)If you need to store a previous state value before update, how would you handle that?

To store a previous state value before it updates, I use the useRef() hook. It keeps a mutable value that doesn’t re-render the component. I update the ref inside a useEffect after each render, and then I can access the previous state value from ref.current.

7)What is the difference between useRef and useState? When would you choose one over the other?

useState is used when we want to store data that affects the UI — updating it triggers a re-render. useRef, on the other hand, stores a mutable value that persists across renders but does not cause re-rendering. I’d use useState for things like counters or input values, and useRef for storing previous state, DOM elements, or values I don’t want to trigger a re-render.

8)How can you use useRef to focus an input field when a button is clicked?

We can use useRef to get direct access to a DOM element. By attaching the ref to an input and calling inputRef.current.focus() inside a button click handler, we can focus the input field programmatically without re-rendering the component.

9)Does changing the value of a useRef variable cause re-render? Why?

In React, useRef is a hook used to store a mutable value or directly access a DOM element without causing a re-render. When we update a useRef variable, React doesn’t re-render the component because it doesn’t track changes to the .current property. It’s mainly used to keep data between renders or to reference elements in the DOM efficiently.

12)What is the difference between using useEffect with:
no dependency array [],empty dependency array [],specific dependency [count]

No dependency array: runs after every render.
Empty dependency array []: runs only once after the initial render.
Specific dependency [count]: runs on initial render and whenever the specified variable (count) changes.

15)You have a form with multiple inputs. How would you manage state for each field efficiently?
//(To Be Discussed)
When you have a form with multiple inputs, the most efficient way is to use a single state object to store all field values instead of using separate useState hooks for each input. This keeps your code scalable and easy to manage.

16)If a React component is re-rendering too many times, how would you optimize it?
//(To Be Discussed)
React component optimization means reducing unnecessary re-renders to improve performance, using techniques like React.memo, useMemo, useCallback, and splitting components.

17)Explain controlled vs uncontrolled components with useRef and useState.
//(To Be Discussed)

Controlled components use React state (useState) to manage input values, so React is the single source of truth and can validate or manipulate input dynamically.
Uncontrolled components use refs (useRef) to access values directly from the DOM, without updating state on every change.

Controlled → dynamic forms, validation.
Uncontrolled → simple forms, access on submit only.

useState in react

Bhuvana Sri R — Wed, 01 Oct 2025 09:27:55 +0000

What is useState in React?

useState is a React Hook that allows you to add and manage state in functional components. It returns the current state value and a function to update it. When the state changes, the component automatically re-renders to reflect the new data.

Syntax of useState :

const [stateVariable, setStateFunction] = useState(initialValue);

stateVariable – The current state value.
setStateFunction – A function used to update that state.
initialValue – The starting value of the state.

Example: Basic Counter Using useState

import React, { useState } from "react";

function Counter() {
  // Declaring a state variable 'count' with an initial value of 0
  const [count, setCount] = useState(0);

  return (
    <div>
      <h2>Count: {count}</h2>
      <button onClick={() => setCount(count + 1)}>Increment</button>
    </div>
  );
}

export default Counter;

Hook in React

Bhuvana Sri R — Wed, 01 Oct 2025 09:18:16 +0000

what is Hook ?

In React, a Hook is a special function that lets you “hook into” React features like state and lifecycle methods inside functional components.
Before hooks were introduced, features like state and lifecycle could only be used in class components. With hooks, you can now use these powerful features directly in functional components — making them more powerful and easier to use.

Commonly Used Hooks

Here are the most commonly used built-in hooks:

useState() – Adds state to a functional component.
useEffect() – Runs side effects (e.g., API calls, DOM updates, timers).
useContext() – Accesses context values without using props.
useRef() – Accesses or stores a DOM element or mutable value.
useMemo() / useCallback() – Optimize performance by memoizing values or functions.

React - Components and props

Bhuvana Sri R — Wed, 01 Oct 2025 09:03:32 +0000

Components :

In react , components is a reusable and independent piece of UI.
Think of its like a function or building block that return html with javascript logic.
Components make your code modular , reusable and easy to maintain.
They can accept props (data) and manage state (their own data).

Types of Components:

Functional Components – These are simple JavaScript functions that return JSX. (Most commonly used today)
Class Components – These are ES6 classes that extend React.Component and include a render() method. (Older style)

Example – Functional Component:

function Welcome(props) 
{
  return <h1>Hello, {props.name}!</h1>;
}

function App() 
{
  return (
    <div>
      <Welcome name="Dharshini" />
      <Welcome name="Keerthi" />
      <Welcome name="Bhuvana" />
    </div>
  );
}

Props (Properties) :

Props stands for properties.
They are like function parameters in JavaScript.
Props are used to pass data from a parent component to a child component.
They are read-only, meaning a child component cannot modify them.

Props Example :

function Child(props) 
{
  return <h2>My favorite color is {props.color}</h2>;
}
function Parent() 
{
  return <Child color="Blue" />;
}

React Introduction

Bhuvana Sri R — Mon, 15 Sep 2025 02:56:19 +0000

What is react ?

React is a javascript library used to build the UI(user interfaces) especially single-page applications(SPAs)
where content updates dynamically without reloading the page.
React focuses only on the ** view layer** (UI rending) and makes it easy to build reusable,component-based UIs.
React follows a component-based architecture, meaning the UI is divided into ** small, reusable pieces** called components.
It uses a Virtual DOM (Document Object Model) for faster rendering and better performance.
React is declarative, meaning you describe what you want the UI to look like, and React updates the** real DOM** for you.

Why React?

Reusable Components
Write once, reuse anywhere → saves time and effort.
Virtual DOM = Faster Performance
React only updates the parts of the page that change, not the entire page.
Component-Based Architecture
Easier to develop, maintain, and scale large applications.
Strong Community & Ecosystem
Backed by Facebook and has a huge developer community, with many libraries/tools.
Cross-Platform Development
With React Native, you can build mobile apps using the same React concepts.
SEO Friendly
React supports server-side rendering, which helps in better search engine optimization.
Easy to Learn for JavaScript Developers
If you know JavaScript + ES6, you can quickly pick up React.

Difference between Library and frameworks:

Library:

library is a set of read-made function that I can call when I need them,so I control the flow .

frameworks:

A framework already has a structure and controls the flow of the application — I just follow its rules.

Javascript -async & await

Bhuvana Sri R — Mon, 15 Sep 2025 02:51:33 +0000

What is async?

async is a keyword used before a function to make it always return a promise.
Example:

async function greet() {
  return "Hello!";
}
greet().then(msg => console.log(msg)); // Output: Hello!

What is await?

await pauses the execution of an async function until a promise resolves.

Example:

async function fetchData() {
  let promise = new Promise((resolve) => {
    setTimeout(() => resolve("Data received!"), 2000);
  });

  let result = await promise;
  console.log(result); // Output after 2s: Data received!
}
fetchData();

How async and await Work Together

Show how they make asynchronous code** look synchronous.**

Compare code written with .then() vs with async/await.
Error Handling with try...catch
Example:

async function getData() {
  try {
    let res = await fetch("https://jsonplaceholder.typicode.com/posts/1");
    let data = await res.json();
    console.log(data);
  } catch (error) {
    console.log("Error:", error);
  }
}
getData();

When to Use async/await

When working with API calls (fetch, Axios).
When you want cleaner code instead of .then() chains.
When error handling is important.

XMLHttpRequest in JavaScript

Bhuvana Sri R — Fri, 12 Sep 2025 02:57:49 +0000

What is XMLHttpRequest (XHR)?

XMLHttpRequest is a built-in JavaScript object used to send HTTP requests to a server and load data without reloading the whole page.
It was introduced in the early 2000s and is the technology behind AJAX (Asynchronous JavaScript and XML).
Even though it has “XML” in its name, it can handle JSON, text, XML, or any data.

Why was it important?

Before XMLHttpRequest, if you wanted new data from the server, the entire web page had to reload.
With XHR, JavaScript could:
Request data asynchronously in the background.
Update part of the page dynamically.

Example :

Basis Syntax

const xhr = new XMLHttpRequest();
xhr.open("GET", "https://jsonplaceholder.typicode.com/posts/1", true);

xhr.onload = function () {
  if (xhr.status === 200) {
    console.log(JSON.parse(xhr.responseText));
  } else {
    console.error("Request failed with status", xhr.status);
  }
};

xhr.onerror = function () {
  console.error("Network error");
};

xhr.send();

Output Example :

For the above request, you’ll get:

{
  "userId": 1,
  "id": 1,
  "title": "sunt aut facere repellat provident occaecati excepturi         optio reprehenderit",
  "body": "quia et suscipit\nsuscipit recusandae..."
}

Works with callbacks (not Promises).
More verbose than fetch.
Still supported in all browsers for backward compatibility.
Mostly replaced by fetch and Axios in modern JavaScript.

XMLHttpRequest still works, but it’s old, clunky, and hard to maintain. That’s why modern code uses fetch or libraries like Axios.

Fetch in JavaScript

Bhuvana Sri R — Fri, 12 Sep 2025 02:42:11 +0000

What is fetch ?

In JavaScript, fetch is a built-in function used to make network requests (like getting data from an API or sending data to a server).
It returns a Promise, which makes it easier to handle asynchronous operations compared to older methods like XMLHttpRequest.

Example :

Basic Syntax

fetch(url, options)
  .then(response => response.json())  // Convert response to JSON
  .then(data => console.log(data))    // Work with the data
  .catch(error => console.error('Error:', error));
  //url → the address of the resource (API endpoint, file, etc.).
  //options → optional object to configure the request (method, headers, body).

GET Request

fetch("https://jsonplaceholder.typicode.com/posts/1")
  .then(response => response.json())
  .then(data => console.log(data));

POST Request

fetch("https://jsonplaceholder.typicode.com/posts", {
    method: "POST",
    headers: {
        "Content-Type": "application/json"
    },
    body: JSON.stringify({
        title: "Hello",
        body: "This is a test",
        userId: 1
    })
})
.then(response => response.json())
.then(data => console.log(data));

fetch is asynchronous (non-blocking).
It always returns a Promise.
Unlike XMLHttpRequest, it’s simpler and modern.
Errors like wrong URL or no internet will trigger .catch().

Difference between fetch and XMLHttpRequest

fetch :

Promise-based (cleaner, easier to chain with .then() / async-await)
Short and simple
Provides convenient methods like .json(), .text(), .blob()
Network errors trigger .catch(), but HTTP errors (like 404/500) must be handled manually
Supports streaming responses
Modern browsers (not IE)

XMLHttpRequest

Callback-based (can get messy with nested callbacks)
Verbose and harder to read
Must manually parse responseText
Must check xhr.status and onerror
Does not support streaming
Works even in old browsers (like IE5+)