Forem: Rahul Raj

About JVM Architecture

Rahul Raj — Mon, 05 Jan 2026 19:18:54 +0000

JVM - Java Virtual Machine

JVM is a software (set of programs) that converts Java bytecode into operating system understandable (machine) code.
The main work of JVM is to load the .class file into JVM memory and execute it.
JVM is called a virtual machine because it runs Java programs like a real computer in software .
Means , JVM is not a physical machine, but it behaves lust like a computer for running Java programs .
A machine is anything that performs work or executes tasks using energy, taking input, processing it, and producing output.
It also manages memory and provides garbage collection facility.
JVM memory is the memory area provided by the OS from RAM, which is organized by JVM to store everything of a Java program, such as objects, fields, variables, class information, and more.
JVM uses an interpreter and JIT compiler to run bytecode faster.

JVM Architecture

JVM Architecture means how JVM is designed internally, or how it works internally – how it loads .class files, executes them, and manages memory .
Entire JVM is divided into 3 - parts
- 1 . Class Loader Sub system
- 2. Runtime Data Area (Memory Area )
- 3. Execution Engine ( Interpreter & JIT Compiler )

1 . Class Loader Sub system

Class Loader Subsystem is a part of JVM and is considered the first layer of JVM.
The main purpose of Class Loader Sub System is to load the .class file into JVM memory ( Method Area ) from Various location .
During class loading, static field(s) get memory and are initialized with default values in the prepare phase, and static blocks are executed in the initialization phase.
- Prepare Phase → Allocate memory for static fields + set default values.
- Initialization Phase → Execute static blocks + assign developer-specified values to static fields.
Class Loader Subsystem internally follows an algorithm called the Delegation Hierarchy Algorithm.
Delegation Hierarchy Algorithm is a technique by which JVM tries to load a .class file into JVM memory. The class loading request first goes from the child class loader to the parent class loader. If the parent loads the required predefined class, the control is returned to the child class loader;
Class Loader Subsystem performs three main tasks internally :
- a. Loading
- b. Linking
- c. Initialization

a. Loading Phase

Loading phase responsibility is to load the .class file into JVM memory (Method Area) and return a Class object.
Loading Phase consists of 3 class Loader
- Bootstrap class Loader (Primordial Class Loader)
- Platform Class Loader ( Extension Class Loader )
- Application Class Loader ( System Class Loader ).

Bootstrap class Loader (Primordial Class Loader)

Bootstrap Class Loader (BCL) is the parent (super) class loader of the Platform Class Loader.
The main responsibility of the Bootstrap Class Loader is to load core Java classes (like Object, String, System, etc.).
These core classes are loaded from the jrt-fs.jar file .
Path of jrt-fs.jar:
- C:\Program Files\Java\JDK\lib\jrt-fs.jar
The first class loaded by the Bootstrap Class Loader is java.lang.Object.
The .class file is stored in the Method Area, and a Class object for that class is returned.
Bootstrap class loader is the virtual machine's built-in class loader, typically represented as null, and does not have a parent.

Platform Class Loader ( Extension Class Loader )

Platform Class Loader is a child of Bootstrap Class Loader and a parent of Application Class Loader.
Loaded .class files are stored in the Method Area, and a Class object is returned.
The .class file is stored in the Method Area, and a Class object for that class is returned.

Note :

Before Java 9 , This is known as Extension Class Loader .
This is because before Java 9, JVM loads the extension / optional (non-core) jar files from the ext (extension) folder.
Path :
- C → Program Files → Java → JDK → lib → ext (extension folder) → extension / optional (non-core) JAR files.
But from Java 9 onwards, JVM loads the extension / optional (non-core) libraries through the Java Platform Module System (JPMS), instead of the ext folder.
Path :
- C → Program Files → Java → JDK → lib → modules → Java platform modules (optional / non-core) .

Application Class Loader ( System Class Loader )

Application Class Loader is subclass of Platform Class Loader.
Its main responsibility is to load all user-defined .class files into the JVM memory .
It loads the .class file from class file path or environment Variable .
For Application Class Loader, the .class file is loaded into the Method Area and a corresponding Class object is returned by the JVM.

Note :

If all the class loaders are not able to load the .class file into the JVM memory then we get runtime called java.lang.ClassNotFoundException .

b. Linking Phase

Linking phase responsibility is to check the .class file, set up memory for static variables, and connect references.
In other words, linking phase verifies, prepares, and resolves the .class file in JVM memory (Method Area).
Linking phase does 3 tasks:
- Verify → Check the .class file
- Prepare → Set up memory for static variables
- Resolve → Connect symbolic references to actual memory addresses

Verify (Check the .class file)

Verify checks the correctness of the .class file. If the .class file is invalid or contains suspicious/illegal bytecode, JVM immediately throws a runtime error called java.lang.VerifyError.
Bytecode Verifier (component of JVM) is responsible for verifying the .class file.
Verify, with the help of Bytecode Verifier, checks the .class file for correctness and safety.
java.lang.VerifyError is a subclass of java.lang.LinkageError.

Prepare → Set up memory for static variables

Prepare phase responsibility is to allocate memory for static fields (primitive or reference) and assign default values.
For reference static fields:
- On a 32-bit system → 4 bytes of memory are allocated
- On a 64-bit system → 8 bytes of memory are allocated
- for reference types / Objects, the default value is always null

Resolve → Connect symbolic references to actual memory addresses

Resolve phase responsibility is to connect symbolic references in the .class file to actual memory addresses.
Symbolic references include classes, methods, and fields used by the class.
JVM replaces these symbolic names with direct references in memory.

// command to get complete info about a compiled .class file
javap -verbose className.class

c. Initialization phase

Initialization phase responsibility is to assign original values to static fields and execute static blocks.
Static fields initialization and static blocks have the same priority, so they are executed in the order they appear in the source code (top to bottom).

Notes:

Before JDK 1.7, JVM checked the main() method after executing static members (static variables and static blocks).
From JDK 1.7 onwards, JVM checks the presence of a valid main() method before executing static variables and static blocks.
So, before Java 1.7, static blocks execute even without main(), but from Java 1.7 onwards, the presence of main() controls whether static blocks execute or not.

RunTime Data Area ( Memory Areas )

Runtime Data Area is a part of the JVM and represents the memory created during program execution.
It is also known as Memory Areas of the JVM.
They are called Runtime Data Areas because these memory areas are created and used only when the program is running (at runtime).
JVM allocates, manages, and releases these areas during program execution, not at compile time.
JVM memory is divided into five Runtime Data Areas depending on variable type, method information, and execution requirements.
....
```
  Will continue…
```

Document object model

Rahul Raj — Wed, 31 Dec 2025 05:24:31 +0000

DOM stands for Document Object Model.

The DOM is created when the browser loads and parses your HTML file. Means Browser creates one object called "document". it keeps complete html and css into document .
DOM is a tree-like object model created by the browser that contains all HTML elements and their attributes.

Step-by-Step (What Browser Does)

when we open an HTML file in the browser then

step 1 : Browser reads HTML line by line

step 2 : Browser converts each HTML tag into DOM nodes

so , Browser is responsible for creating the DOM from the HTML file.
JavaScript can now access the DOM
DOM is created BEFORE JavaScript starts manipulating it.
document object stores html and css in a tree structure called "DOM Tree".
Each DOM element can have its own CSS styles applied to it.
DOM is a collection of objects that represent HTML elements.
Each element node has a tag name, attributes, and content.

HTML file
   ↓
Browser parses HTML
   ↓
DOM Tree created
   ↓
JavaScript interacts with DOM

we can select the dom elements , manipulate the dom elements as well as we can also create DOM elements with the help of java Script .

How to Select Elements in the Document

In JavaScript, there are 5 ways to select elements from the document.

1. with the help of `getElementById("id")`

here , we select an HTML element from the document object with the help of the id of a particular HTML element.
It returns the single HTML element reference .

// html 
 <h1 id="title">Hello</h1>

// js 
let headingObjReference = document.getElementById("title");
console.log(headingObjReference);

// In console 
 <h1 id="title">Hello</h1>

2. by using `getElementsByClassName('className')`

Here, we select HTML element(s) from the document object with the help of the class name of the HTML element(s).
It returns an HTMLCollection (array-like object) containing all the HTML element(s) having the given class name.
With the help of the elements’ references, we can change the content as well as the CSS styles of the HTML elements.

// html 
<p class="text">Hello</p>
<p class="text">World</p>

//js
let allSameClassElementsReference = document.getElementsByClassName("text");

console.log(allSameClassElementsReference );      // HTMLCollection
console.log(allSameClassElementsReference [0]);

HTMLCollection(2) [p.text, p.text]
<p class="text">Hello</p>

3. With the help of getElementsByTagName('tagName')

Here, we select HTML element(s) from the document object with the help of the tag name of the HTML element(s).
It returns an HTMLCollection (array-like object) containing all the HTML element(s) having the same tag name.
With the help of the elements’ references, we can change the content as well as the CSS styles of the HTML elements.

// HTML 
<p>One</p>
<p>Two</p>

// js code
let allSameTagElementsReference = document.getElementsByTagName("p");
console.log(allSameTagElementsReference);

HTMLCollection(2) [p, p]

4. With the help of querySelector('query')

It selects and returns only the first HTML element that satisfies the given CSS selector query.
If no element matches the query, it returns null.
We can use id, class, tag, attribute, or any CSS selector inside querySelector().

In css file , how to access elements with  id , class name , tag name 
- for id , 
         # idName

- for class Name 
           .className

- for tag name 
         tagName

//html

<h1 class="title">Hello</h1>
<h1 class="title">World</h1>

//js 
let element = document.querySelector(".title");
console.log(element);

<h1 class="title">Hello</h1>

//eg 2 
//HTML

<div id="box">
  <p>Hello ApnaMart!</p>
</div>

// js 
let para = document.querySelector("#box p");
console.log(para.innerText); // Hello ApnaMart!

Hello ApnaMart!

5 . With the help of querySelectorAll('query')

Here, we select all HTML elements from the document object that satisfy the given CSS selector query.
The returned NodeList is array-like and can be accessed using index.
With the help of the elements’ references, we can change the content as well as the CSS styles of the HTML elements.

// html
<p class="text">One</p>
<p class="text">Two</p>
<p class="text">Three</p>

// js
let elements = document.querySelectorAll(".text");

console.log(elements);

NodeList(3) [p.text, p.text, p.text]

Modifying Content of an Element

1. innerText – Update Visible Text

2. textContent – Update All Text

3. innerHTML – Update HTML Content

1. innerText – Update Visible Text

innerText = “visible text only”
Shows only what we see on page, ignores hidden text
We can read it or change it
If element is hidden, innerText may not work properly

<div id="box">
  <p>Hello</p>
</div>

<script>
  let box = document.getElementById("box");

  // read content
  console.log(box.innerText); // Hello

  // change content
  box.innerText = "Welcome to ApnaMart!";
</script>

//eg 1

<h1 id="title1">Hello World</h1>
<script>
  let title = document.getElementById("title1");
  title.innerText = "Welcome to ApnaMart!";
</script>

Welcome to ApnaMart!

//eg 2 

<h1 id="title" style="display:none;">Hello World</h1>

<script>
  let title = document.getElementById("title");
  title.innerText = "Welcome to ApnaMart!";
  console.log(title.innerText); // Check in console
</script>

Hello World

2. textContent – Update All Text

textContent = “all text inside element”
Shows everything inside element, including hidden text
We can read it or change it
Doesn’t care about styles, faster than innerText

<div id="box">
  <p>Hello <span style="display:none">Secret</span></p>
</div>

<script>
  let box = document.getElementById("box");

  // read content
  console.log(box.textContent); // Hello Secret

  // change content
  box.textContent = "Shop Online Easily!";
</script>

//eg2

<h1 id="title2">Hidden <span style="display:none">Secret</span> Text</h1>
<script>
  let title = document.getElementById("title2");
  title.textContent = "Shop Online Easily";
</script>

Shop Online Easily

3. innerHTML – Update HTML Content

innerHTML = “inside HTML”
Shows everything inside element, even HTML tags
We can read it or change it
If we add HTML tags, browser will show them, not as plain text

//eg 1 

<div id="box">
  <p>Hello</p>
</div>

<script>
  let box = document.getElementById("box");

  // read content
  console.log(box.innerHTML); // <p>Hello</p>

  // change content
  box.innerHTML = "<b>Welcome to ApnaMart!</b>";
</script>

Array Operations in JavaScript

Rahul Raj — Fri, 26 Dec 2025 05:24:16 +0000

Array :

An Array is a linear data structure used to store multiple values, accessed using zero-based indexing.
It is used to store multiple values in a single variable.
Arrays can store different data types value (number, string, boolean , object, etc.).
Arrays are represented using square brackets [].
Each value inside an array is called an element.
Every array has a property called length. It returns the total number of elements in array .
Arrays are mutable, means we can change the length of array as well as modify the value of array .

Array Operations :

1 . push()

if we want to add one or more elements to the end of an array then we need to use push() .
it modify the existing original array not return new Array
it returns the new array length .
pros : operations are simple & fast .
cons : change the original array .

let arr = [1, 2, 3];

let returnedValue = arr.push(4);

console.log(arr);           
console.log(returnedValue);

Output

[1, 2, 3, 4]
 4

2 . pop()

if we want to remove/delete only last element from the array then we need to use pop().
It also modify the original array .
It returns the deleted element .
pros : easy to use
cons : change the original array .

let arr = [10, 20, 30];

let returnedValue = arr.pop();

console.log(arr);          
console.log(returnedValue);

Output

[ 10, 20 ]
30

3 . unshift()

if we want to add one or more elements at starting then we need to use unshift().
it modify the original array .
It returns the new array length .

let arr = [2, 3];

let returnedValue = arr.unshift(0,1);

console.log(arr);          
console.log(returnedValue);

Output

[ 0, 1, 2, 3 ]
4

4 . shift()

if we want to remove/delete only first element of array then we need to use shift().
it modifies the original array .
It returns the deleted element .

let arr = [1, 2, 3];

let returnedValue = arr.shift();

console.log(arr);          
console.log(returnedValue);

Output

[ 2, 3 ]
1

5 . splice()

if we want to add / delete / replace one or more element(s) at specific index , then we need to use splice().
It modifies the original Array.
It returns the array of removed elements . if we will not delete any element from the array then it returns empty array . -Syntax :
- arr.splice(start,deleteCount, item1, item2, …);

let arr = [1, 2, 3];
let result = arr.splice(1, 1, 10, 20); // add 10,20 at index 1, remove 0 elements

console.log(result); 
console.log(arr);

Output

[ 2 ]
[ 1, 10, 20, 3 ]

Note :

splice(start) : Removes everything from start to end & return -> Array of removed elements .
splice(start, 0) : Removes 0 elements → add nothing & return -> [] empty array .
splice(start, deleteCount) : Removes deleteCount elements from start & return -> Array of removed elements .
splice(start, deleteCount, item1, item2, …) : Remove deleteCount elements from start and insert new items & return -> Array of removed elements

6 . map()

If we want to make a new array from an existing array based on some condition or change, we use map().
The new array will always have the same number of elements as the original array.
Original array does not change .
map() returns new array of same length.

let nums = [1, 2, 3];

let returnedValue = nums.map(n => n * 2);

console.log(nums);         
console.log(returnedValue);

Output

[ 1, 2, 3 ]
[ 2, 4, 6 ]

let nums = [1, 2, 3, 4, 5];

let newNums = nums.map(n => {
  if (n % 2 === 0) {
    return n * 2;   
  } else {
    return n;      
  }
});

console.log(nums);   
console.log(newNums);

Output

[ 1, 2, 3, 4, 5 ]
[ 1, 4, 3, 8, 5 ]

let nums = [1, 2, 3, 4, 5];

let newNums = nums.map(n => {
  if (n % 2 === 0) return n * 2;
  else if (n === 3) return 99;
  else return n;
});

console.log(newNums);

Output

[ 1, 4, 99, 8, 5 ]

7 . filter()

if we want to create an array based on some match condition from existing array then we need to use filter().
here , existing array does not change .
filter() return new array based on match condition .
Length of new array ≤ original array.

let nums = [10, 15, 20];

let returnedValue = nums.filter(n => n > 10);

console.log(nums);         
console.log(returnedValue);

Output

[ 10, 15, 20 ]
[ 15, 20 ]

let nums = [5, 10, 15, 20, 25, 30];

let filtered = nums.filter(n => {
  if (n % 2 === 0 && n > 10) {

    return true;
  } else if (n === 5 || n === 15) {

    return true;
  } else {

    return false;
  }
});

console.log(filtered); 
console.log(nums);

Output

[ 5, 15, 20, 30 ]
[ 5, 10, 15, 20, 25, 30 ]

let nums = [5, 10, 15, 20, 25, 30];

let filtered = nums.filter(n => (n % 2 === 0 && n > 10) || n === 5);
// even numbers greater than 10 OR number equal to 5

console.log(filtered);

Output

[ 5, 20, 30 ]

8 reduce()

If we want to perform a sum operation on all elements of a given array and convert them into a single value, then we use the reduce() method.
Reduces the array to a single value.
Return -> Single value
reduce() does not modify the original array.
It only reads elements and returns a single value.

let nums = [10, 20, 30];

let sum = nums.reduce((total, n) => total + n, 0);

console.log(sum);  
console.log(nums);

Output

60
[ 10, 20, 30 ]

note : total(here) -> Something that collects or gathers values step by step OR An accumulator is a variable(total) that stores the running total or combined result .

9. includes()

-If we want to check whether a particular element is present in a given array or not, we use includes().

Returns boolean → true or false
Does not change the original array.

let arr = ["JS", "Java"];

let returnedValue = arr.includes("JS");

console.log(arr);          
console.log(returnedValue);

Output

[ 'JS', 'Java' ]
true

10. find()

It is used to return the first element that matches the given condition.
When only one result is required.
return either Single value or undefined.
Does not change the original array.

let nums = [5, 12, 8];

let returnedValue = nums.find(n => n > 10);

console.log(nums);        
console.log(returnedValue);

Output

[ 5, 12, 8 ]
12

Note :

Non-mutating methods → map(), filter(), reduce(), find(), includes()

Mutating methods → push(), pop(), shift(), unshift(), splice(), sort()

Heap & Stack Diagram in java

Rahul Raj — Wed, 24 Dec 2025 02:56:41 +0000

Heap Area :

in java , Object Present in Heap Area.
Object having 2 things that is Non - static field(s) and Non - static method(s).
So, Non - static field(s) and non - static method(s) also present in heap area.

Stack Area :

Stack Area follows First In Last Out (FILO) or Last In First Out(LIFO) technique .
In java , local variable(s) & parameter variable(s) present in stack area .
Each method having individual stack memory in Stack Area and it follow LIFO technique .
Means If method execution completed then delete from the Stack Area.

Note :

Primitive Field(s) / Primitive variable(s) holds direct value .
Reference Field(s) / Reference variable(s) holds reference of Object instead of direct value .

public class Test
{
    Test t;
    int val;

    public Test(int val)
    {
        this.val = val;
    }

    public Test(int val, Test t)
    {
        this.val = val;
        this.t = t;
    }

    public static void main(String[] args)
    {
        Test t1 = new Test(100);
        Test t2 = new Test(200, t1);
        Test t3 = new Test(300, t1);
        Test t4 = new Test(400, t2);

        t2.t = t3;
        t3.t = t4;
        t1.t = t2;
        t2.t = t4.t;

        System.out.println(t1.t.val);
        System.out.println(t2.t.val);
        System.out.println(t3.t.val);
        System.out.println(t4.t.val);
    }
}

Output :

Array Searching Techniques - Linear Search & Binary Search

Rahul Raj — Fri, 19 Dec 2025 19:14:10 +0000

Linear Search :

Linear Search is a searching technique in which we try to search an element either from Starting index to last index or last index to Starting Index and traverse the entire Array.
Here , Array may be either Sorted or not sorted.
Time complicity = O(n).


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

        int [] a = {4 , 7 , 1 , 5 , 9 ,0};
        int searchingElement = 9;
        boolean isFound=false;
        int indexValue=-1;
        for(int i=0;i<a.length;i++){
            if(a[i]==searchingElement){
                isFound=true ; 
                indexValue=i;

            }
        }
        if(isFound==true){
          System.out.println(searchingElement+" is present at index "+indexValue);  
        }
        else{
            System.out.println(searchingElement+" is not present in given Array .");
        }
    }
}

OUTPUT

9 is present at index 4

Binary Search

Binary Search is a searching technique in which we try to search a particular element in a sorted array by repeatedly dividing the search space into two halves.
mid = (start + end)/2;
Here Array must be sorted either increasing or decreasing Order .

// this code  for sorted array in increasing Order 
class Main {
    public static void main(String[] args) {

        int [] a = {1,2,3,4,5,6,7,8,9};
        int searchingElement = 1;
        boolean isFound=false;
        int indexValue=-1;
        int startIndex=0;
        int lastIndex=a.length-1;
        while( startIndex<=lastIndex){
            int mid = (startIndex+lastIndex)/2;

            if(a[mid]==searchingElement){
                isFound=true;
                indexValue=mid;
                break;
            }
            else if(a[mid] < searchingElement){
               startIndex=mid+1; 
            }
            else{
                lastIndex=mid-1;
            }
        }



        if(isFound==true){
          System.out.println(searchingElement+" is present at index "+indexValue);  
        }
        else{
            System.out.println(searchingElement+" is not present in given Array .");
        }
    }
}

Output

1 is present at index 0

Rotate Array in clock Wise

Rahul Raj — Wed, 17 Dec 2025 20:18:39 +0000

What is Array Rotation?

Array rotation is the process of shifting the elements of an array to new positions by a certain number of times (k).

There are two types of array rotation:

Clockwise rotation (Right rotation / Right shift)
Anti-clockwise rotation (Left rotation / left shift)

What is Clockwise Rotation?

Clockwise rotation means shifting the array elements to the right.
In this process, the last element moves to the first position, and all other elements shift one position to the right.

Step for clock wise rotation

Step 1: Reverse whole array

Step 2: Reverse first k elements (0 to k-1)

Step 3: Reverse elements from k to (size-1)


class Main {
public static void reverseArray(int [] arr , int sIndex , int eIndex){
    while(sIndex<eIndex){
        arr[sIndex ]=(arr[sIndex ]+arr[eIndex ])-(arr[eIndex ]=arr[sIndex ]);
        sIndex++; eIndex--;
    }


    }
    public static void main(String[] args) {
        int [] num = {10,20,30,40,50};
        int k =2;
        k = k%num.length;
         System.out.println("original Array : ");
        for(int i = 0 ; i<num.length;i++){
            System.out.print(num[i]+" ");
        }
        // step 1 
        reverseArray(num , 0 , num.length-1);
        //step 2 
        reverseArray(num , 0 , k-1);
        // step 3 
        reverseArray(num ,k, num.length-1);

        System.out.println();
        System.out.println("After "+k+"th clock wise rotation : ");
        for(int i = 0 ; i<num.length;i++){
            System.out.print(num[i]+" ");
        }

    }
}

Output :

original Array : 
1 2 3 4 5 
After 2th clock wise rotation : 
4 5 1 2 3

Method Overriding In Java

Rahul Raj — Mon, 15 Dec 2025 05:32:06 +0000

What is Method Overriding ?

Method overriding is a technique in which when child class provides its own implementation/body of a method that is already define in its parent class .
Parent class method → Overridden method .
Child class method → Overriding method .
For method overriding, the inheritance concept is compulsory.


class Main {
    public static void main(String[] args) {
      Parent p1 = new Parent();
      p1.display();
      Child c1 = new Child();
      c1.display();
      Parent p2 = new Child();
      p2.display();

       // Child c2 = new Parent();

    }
}

class Parent {
    public void display(){
        System.out.println("This is parent class ");
    }
} 

class Child extends Parent {
    public void display(){
        System.out.println("This is Child class ");
    }

}

Output

This is parent class 
This is Child class 
This is Child class

Rules for defining an overriding method:

Rule 1 : Method name must be Same .
Rule 2 : Method Parameter Must be same .
Note : Rule 1 & Rule 2- Together we can say method signature must be same .
Rule 3 : We can not assign More restrictive Access Modifier for overriding method (method in child class )

class Test {
    public static void main(String[] args) {
      Parent p1 = new Parent();
      p1.display();
      Child c1 = new Child();
      c1.display();
      Parent p2 = new Child();
      p2.display();
    //   Child c2 = new Parent();

    }
}

class Parent {
    public void display(){
        System.out.println("This is parent class ");
    }
} 

class Child extends Parent {
    protected void display(){ // error 
        System.out.println("This is Child class ");
    }

}

Output :

error: display() in Child cannot override display() in Parent
    protected void display(){
                   ^
  attempting to assign weaker access privileges; was public
1 error
ERROR!
error: compilation failed

Note : private(more restrictive access modifier ) → default → protected → public (less restrictive access modifier )
Rule 4 : for return type

a>. Up to Java 1.4 version, the return type must be exactly the same.
b>. From Java 1.5 onwards,
for primitive return types : the return type must be the same;
for reference types (objects, classes, or interfaces), covariant return types are allowed.

note : If a parent class method has a void return type, then the overriding child class method must also have a void return type.


class Test {
    public static void main(String[] args) {
      Parent p1 = new Parent();
     System.out.println("Parent Class Method "+p1.display());
      Child c1 = new Child();
      System.out.println("Child Class Method "+c1.display());
      Parent p2 = new Child();
     System.out.println("Child Class Method "+p2.display());


    }
}

class Parent {
    public int display(){
        return 10;
    }
} 

class Child extends Parent {
    public int display(){
        return 20;
    }

}

Output

Parent Class Method 10
Child Class Method 20
Child Class Method 20

note : Covariant return type is applicable only to reference types (classes or interfaces), not to primitive data types.
Covariant return type means that when a method is overridden in a child class, the return type of the child method can be a subclass of the return type of the parent class method.


class Test {
    public static void main(String[] args) {
      Parent p1 = new Parent();
     System.out.println("Parent Class Method "+p1.display());
      Child c1 = new Child();
      System.out.println("Child Class Method "+c1.display());
      Parent p2 = new Child();
     System.out.println("Child Class Method "+p2.display());


    }
}

class Parent {
    public Object display(){
        return 10;
    }
} 

class Child extends Parent {
    public String display(){
        return "20";
    }

}

Output

Parent Class Method 10
Child Class Method 20
Child Class Method 20

Another Example of Covariant Return Type :


class Test {
    public static void main(String[] args) {
      Parent p1 = new Parent();
     System.out.println("Parent Class Method "+p1.display());
      Child c1 = new Child();
      System.out.println("Child Class Method "+c1.display());
      Parent p2 = new Child();
     System.out.println("Child Class Method "+p2.display());


    }
}

class Parent {
    public  Number  display(){
        return 10;
    }
} 

class Child extends Parent {
    public Integer display(){
        return 20;
    }

}

Rule 5 : Rules for defining a method as final

a>If a parent class method is final, then we cannot override that method in the child class; otherwise, we get a compile-time error.

b> We may define a child class method as final; there is no problem.


class Test {
    public static void main(String[] args) {
      Parent p1 = new Parent();
     System.out.println("Parent Class Method "+p1.display());
      Child c1 = new Child();
      System.out.println("Child Class Method "+c1.display());
      Parent p2 = new Child();
     System.out.println("Child Class Method "+p2.display());


    }
}

class Parent {
    public Object display(){
        return 10;
    }
} 

class Child extends Parent {
    public final String display(){
        return "20";
    }

}

Output :

Parent Class Method 10
Child Class Method 20
Child Class Method 20

Rule 6 : We can define both parent class and child class methods as private; there is no issue.

class Test {
    public static void main(String[] args) {
      //Parent p1 = new Parent();
     //p1.display();
      Child c1 = new Child();
      c1.display();
      //Parent p2 = new Child();
     //p2.display();


    }
}

class Parent {
     private  void  display(){
       System.out.println("parent class private method ");
    }

} 

class Child extends Parent {
    public  void display(){
       System.out.println("child class non - private display  method ");
    }

}

OutPut :

child class non - private display  method

Rule 7 :If a parent class method is static but the child class method is non-static, it is not allowed to override, and vice versa. But , We can define a method as static in both parent and child classes.(method hiding)


class Test {
    public static void main(String[] args) {
      Parent p1 = new Parent();
     p1.display();
      Child c1 = new Child();
      c1.display();
      Parent p2 = new Child();
     p2.display();


    }
}

class Parent {
     public static  void  display(){
       System.out.println("parent class private method ");
    }

} 

class Child extends Parent {
      void display(){
       System.out.println("child class non - private display  method ");
    }

}

output

 error: display() in Child cannot override display() in Parent
      void display(){
           ^
  overridden method is static
1 error


class Test {
    public static void main(String[] args) {
      Parent p1 = new Parent();
     p1.display();
      Child c1 = new Child();
      c1.display();
      Parent p2 = new Child();
     p2.display();


    }
}

class Parent {
     public static  void  display(){
       System.out.println("parent class private method ");
    }

} 

class Child extends Parent {
     public static void display(){
       System.out.println("child class non - private display  method ");
    }

}

parent class private method
child class non - private display  method
parent class private method


class Test {
    public static void main(String[] args) {
      Parent p1 = new Parent();
     p1.display();



    }
}

class Parent {
     public   void  display(){
       System.out.println("parent class private method ");
    }

} 

 abstract class Child extends Parent {
     public abstract void display();

}

parent class private method

class Test {
    public static void main(String[] args) {
      //Parent p1 = new Parent();
     //p1.display();




    }
}

abstract class Parent {
     public  abstract void  display();

} 

 abstract class Child extends Parent {
     public abstract void display();

}

//output ->  blank page

Array and String Manipulation Problems

Rahul Raj — Fri, 12 Dec 2025 20:59:10 +0000

case 1 : Reverse an array using another array



class Main {
    public static void main(String[] args) {
        int [] num = {10,11,12,13,14,15,16};
        System.out.println("Original Array :");
         for(int i=0;i<num.length;i++){
            System.out.print(num[i]+"  ");
        }
        //Create a result array to hold the required values, having the same length as num.
        int [] result = new int[num.length];

        // reverse the array here
        for(int i=num.length-1,j=0;i>=0;i--){
           result[j++]=num[i]; 
        }
        System.out.println();
        System.out.println("Reversed  Array :");
        // print the resultant array 
        for(int i=0;i<result.length;i++){
            System.out.print(result[i]+"  ");
        }
    }
}

case 2 : Reverse an array in-place without extra space

A palindrome number is a number which remains the same when it is reversed.



class Main {
    public static void main(String[] args) {
        int [] num = {10,11,12,13,14,15,16};
        System.out.println("Original Array :");
         for(int i=0;i<num.length;i++){
            System.out.print(num[i]+"  ");
        }
        System.out.println();
        int left =0;
        int right = num.length-1;
        while(left < right){
            num[left] = (num[left]+num[right])-(num[right]=num[left]);
            left++; right--;
        }
        System.out.println("Reversed Array :");
         for(int i=0;i<num.length;i++){
            System.out.print(num[i]+"  ");
        }
    }   

    }

case 3 : Check whether the given string is a palindrome or not



class Main {
    public static void main(String[] args) {
     String str = "abcdcba";
     int left =0;
     int right=str.length()-1;
     boolean flag = true;
     while(left < right){
         if(str.charAt(left)!=str.charAt(right)){
             flag=false;
             break;
         }
         left++; right--;
     }
     if(flag==true){
         System.out.println(str+" is palindrome number");
     }
     else{
         System.out.println(str+" is not palindrome number");
     }
    }
}

Shallow & Deep Copy In Java

Rahul Raj — Fri, 12 Dec 2025 05:27:31 +0000

Shallow Copy :

Shallow copy is a technique in which we have more than one reference variable pointing to the same object, means here we try to copy the reference of the object.
If we change anything in the object with the help of any one of the reference variable then that change will be reflected to all the reference variables.
Here we try to copy reference of object not creating a new object .

Shallow Copy Example

//ELC
class Test
{
    public static void  main(String []args){
        Employee emp1 = new Employee(10000);
        System.out.println(emp1.getSalary()); //
        System.out.println(); //

        Employee emp2 = emp1 ; 

        emp2.setSalary(20000); 
        System.out.println(emp1.getSalary()); //
        System.out.println(emp2.getSalary()); //
    }
}

// BLC class 
class Employee
{
    double salary;
    Employee(double salary){
        this.salary=salary;
    }   
    public double getSalary(){
        return this.salary;
    }
    public void setSalary(double salary){
        this.salary = salary;
    }
}

Deep Copy

Deep copy is a technique in which always try to create a new Object .
Generally we create new object with the help of new Keyword .
new keyword is dynamic memory allocation operator .
new keyword always create a new object .


//ELC
class Test
{
    public static void  main(String []args){
    Employee emp1 = new Employee();
    Employee emp2 = new Employee(2000);
    emp1.setSalary(emp2.getSalary());
    System.out.println(emp1.getSalary());
    System.out.println(emp2.getSalary());
    System.out.println();
    emp1.setSalary(80000);
    System.out.println(emp1.getSalary());
    System.out.println(emp2.getSalary());

    }
}

// BLC class 
class Employee
{
    double salary;
    Employee(){}
    Employee(double salary){
        this.salary=salary;
    }   
    double getSalary(){
        return this.salary;
    }
    void setSalary(double salary){
        this.salary = salary;
    }
}

Pass By Value :

we have to type of variable .

Primitive variable
Reference variable

case 1 : when we pass Primitive Variable

when we pass primitive variable then we pass actual value .


class Test
{
    public static void  main(String []args){
Test t1 = new Test();
    int x = 10;
    System.out.println(x);
    t1.display(x);
    System.out.println(x);  
    }
    void display(int y ){
        y = y+10;
        }
}

case 2 : when we pass Reference Variable

when we pass Reference variable then we pass Reference of Object not actual object .
Means here we try to copy reference of object not creating Object .
It is look like Shallow Copy concept ..

What is class , abstract class & interface .

Rahul Raj — Thu, 11 Dec 2025 05:35:21 +0000

What is class ?

class is blueprint from which we create object.
we declare class with the help of class keyword.
Inside the class, we can directly write fields (non-static / static), blocks (non-static / static), constructors, concrete methods (non-static / static), inner classes, interfaces, and so on.
Generally, we can create object of class with the help of new keyword.
class is also a user-defined data type.
we cannot write abstract method inside the normal class.

Abstract Class :

Abstract class is declare with the abstract keyword .
We can not create object of the abstract class .
Abstract class may contain non - abstract method ( concrete methods ) , may contain abstract method , may contain non - static field . may contain static field .
Abstract class can not be final .
for declare abstract class , we use abstract keyword.

Note :

Abstract method is type of method having no body . We have to provide body of abstract method in their child class .

interface :

Interface is a blueprint that contains abstract methods and constant (public static final) variables.
for declare interface , we use interface keyword .
with the help of interface , we achieve multiple inheritance .

Different Ways to Find Even and Odd Numbers

Rahul Raj — Tue, 09 Dec 2025 19:20:57 +0000

If a number is divisible by 2, then the number is called an even number; otherwise, it is an odd number.
Example of even numbers : 0 , 2 , 4 , 6 , 8 ...
Example of odd numbers : 1 , 3 , 5 , 7 , 9 ...

case 1 : using % operator

//using % operator

class Main {

    public static void main(String[] args) {

      int num =101;
     System.out.println(
         (num%2==0)
                ?num+" is Even Number . "
                :num+" is Odd Number . "

         );
    }
}

case 2 : Using the minus (–) operator

// using minus operator

class Main {

    public static void main(String[] args) {

      int num =101;
      int temp = num;
      while(temp>0){
          temp -=2;
      }
      if(temp==0){
          System.out.println("even");
      }
      else {
          System.out.println("odd");
      }
    }
}

case 3 : using division & multiplication operator

// using division ( / ) & multiplication ( * ) operator 

class Main {

    public static void main(String[] args) {

      int num =101;
    String result = ((num/2)*2==num)
                            ?"Even Number ."
                            :"Odd Number . "
                            ;

    System.out.println(num+" is "+result);
    }
}

case 4 : using bit wise and ('&') operator

//using bit wise and ('&') operator 

class Main {

    public static void main(String[] args) {

      int num =102256;
    String result = ((num & 1) ==0)
                            ?"Even Number ."
                            :"Odd Number . "
                            ;

    System.out.println(num+" is "+result);
    }
}

case 5 : using bitwise or( | ) Operators

// using bitwise or( | ) Operators 

class Main {

    public static void main(String[] args) {

      int num =1022561;
    int result = num | 1;

    System.out.println(
        (result == num)
                ?num+" is Odd Number ."
                :num+" is Even Number . "
        );

    }
}

case 6 : Using Recursion

// Using Recursion

class Main {

    public static boolean isEvenOdd(int num){
        if(num<0){
            num *=-1;
        }
        if(num==0) return true;
        else if(num == 1) return false ;

     return  isEvenOdd(num - 2);

    }
    public static void main(String[] args) {

      int num =1221;
       boolean result = isEvenOdd(num);
       System.out.println(
            result
               ? num+" is Even number . "
               :num+" is odd Number . "

       );
}
}

case 7 : Using String

// using String 

class Main {


    public static void main(String[] args) {
        long num=101222222222222222l;
        String numString=num+"";
        char lastDigit = numString.charAt(numString.length()-1);
        if(lastDigit=='0' || lastDigit=='2' || lastDigit=='4' || lastDigit=='6' || lastDigit=='8'){
            System.out.println(num+" is Even Number .");
        }
        else {
            System.out.println(num+" is odd Number .");

        }

  }
}

[Boost]

Rahul Raj — Tue, 09 Dec 2025 08:03:15 +0000

Forem: Rahul Raj

About JVM Architecture

JVM - Java Virtual Machine

JVM Architecture

1 . Class Loader Sub system

a. Loading Phase

Bootstrap class Loader (Primordial Class Loader)

Platform Class Loader ( Extension Class Loader )

Note :

Application Class Loader ( System Class Loader )

Note :

b. Linking Phase

Verify (Check the .class file)

Prepare → Set up memory for static variables

Resolve → Connect symbolic references to actual memory addresses

c. Initialization phase

Notes:

RunTime Data Area ( Memory Areas )

Document object model

DOM stands for Document Object Model.

Step-by-Step (What Browser Does)

How to Select Elements in the Document

1. with the help of getElementById("id")

2. by using getElementsByClassName('className')

3. With the help of getElementsByTagName('tagName')

4. With the help of querySelector('query')

5 . With the help of querySelectorAll('query')

Modifying Content of an Element

1. innerText – Update Visible Text

2. textContent – Update All Text

3. innerHTML – Update HTML Content

Array Operations in JavaScript

Array :

Array Operations :

1 . push()

Output

2 . pop()

Output

3 . unshift()

Output

4 . shift()

Output

5 . splice()

Output

Note :

6 . map()

Output

Output

Output

7 . filter()

Output

Output

Output

8 reduce()

Output

9. includes()

Output

10. find()

Output

Note :

Heap & Stack Diagram in java

Heap Area :

Stack Area :

Note :

Output :

Array Searching Techniques - Linear Search & Binary Search

Linear Search :

OUTPUT

Binary Search

Output

Rotate Array in clock Wise

What is Array Rotation?

What is Clockwise Rotation?

Output :

Method Overriding In Java

What is Method Overriding ?

Output

Rules for defining an overriding method:

Output :

Output

1. with the help of `getElementById("id")`

2. by using `getElementsByClassName('className')`