Forem: scindia bethuraj

Day 9 of My Java Automation Journey – Understanding Types of Inheritance

scindia bethuraj — Wed, 04 Mar 2026 20:30:56 +0000

Trainer : Mr. Nantha
Day 9
Understanding inheritance is essential because it helps in code reuse, structured design, and real-world modeling.

What is Inheritance in Java?

Inheritance is a mechanism in Java where a child class acquires the properties and behaviors of a parent class.

It represents an IS-A relationship.

Example

Developer is an Employee

SeniorDeveloper is a Developer

This allows classes to reuse existing code instead of rewriting it.

Types of Inheritance in Java

Java supports several inheritance structures:

Single Inheritance

Multiple Inheritance

Hierarchical Inheritance

Multilevel Inheritance

Hybrid Inheritance

Let’s explore each one.

Single Inheritance
Definition

Single inheritance occurs when one child class inherits from one parent class.

Structure
Parent → Child
Example
Animal → Dog
Code Example
class Animal {
void eat() {
System.out.println("Animal eats food");
}
}

class Dog extends Animal {
void bark() {
System.out.println("Dog barks");
}
}
Explanation

Dog inherits the eat() method from Animal.

Dog also has its own method bark().

This improves code reusability.
Multiple Inheritance
Definition

Multiple inheritance occurs when one child class inherits from more than one parent class.

Structure
Parent1
\
Child
/
Parent2
Example (Conceptual)
Father
\
Child
/
Mother
Problem – Ambiguity Issue

If both parents have the same method:

void work()

Java cannot determine:

Should the child use Father.work()
or

Mother.work()?

This confusion is called the Ambiguity Problem.

Important Rule

🚫 Java does NOT support multiple inheritance using classes.

Example that causes an error:

class Child extends Father, Mother { }

This will produce a compile-time error.

But Java Allows Multiple Inheritance via Interfaces

Example:

interface Camera {
void takePhoto();
}

interface MusicPlayer {
void playMusic();
}

class Smartphone implements Camera, MusicPlayer {
public void takePhoto() {
System.out.println("Taking Photo");
}

public void playMusic() {
    System.out.println("Playing Music");
}

}

Here a class can implement multiple interfaces safely.

Hierarchical Inheritance
Definition

Hierarchical inheritance occurs when multiple child classes inherit from a single parent class.

Structure
Vehicle
/ \
Car Bike
Example Code
class Vehicle {
void start() {
System.out.println("Vehicle starts");
}
}

class Car extends Vehicle {
void drive() {
System.out.println("Car drives");
}
}

class Bike extends Vehicle {
void ride() {
System.out.println("Bike rides");
}
}
Explanation

Both Car and Bike inherit the start() method from Vehicle.

Benefits:

Code reuse

Better organization

Common functionality centralized

Multilevel Inheritance
Definition

Multilevel inheritance occurs when a class inherits from another class, and then another class inherits from that class.

Structure
Grandparent → Parent → Child
Example
Animal → Dog → Puppy
Code Example
class Animal {
void eat() {
System.out.println("Animal eats");
}
}

class Dog extends Animal {
void bark() {
System.out.println("Dog barks");
}
}

class Puppy extends Dog {
void weep() {
System.out.println("Puppy weeps");
}
}
Execution
Puppy p = new Puppy();

p.eat(); // from Animal
p.bark(); // from Dog
p.weep(); // from Puppy
Output
Animal eats
Dog barks
Puppy weeps

Why Multilevel Inheritance is Powerful

✔ Reusability across multiple layers
✔ Represents real-world hierarchies
✔ Makes code scalable
✔ Easy to extend functionality

Real-world example:

Person → Employee → Developer → SeniorDeveloper

Hybrid Inheritance
Definition

Hybrid inheritance is a combination of two or more inheritance types.

Example:

Multilevel + Hierarchical

Structure Example
Vehicle
/ \
Car Bike
|
ElectricCar
Important Rule

Java does not support hybrid inheritance using classes directly because it may involve multiple inheritance, which causes ambiguity.

However, it can be achieved using interfaces.
Key Concepts Learned Today

✔ Types of inheritance in Java
✔ Why Java avoids multiple inheritance with classes
✔ Ambiguity problem
✔ Hierarchical inheritance structure
✔ Multilevel inheritance
✔ Introduction to method overriding
✔ Real-world class hierarchy design

Constructors, Default Values & Object Initialization in Java

scindia bethuraj — Fri, 27 Feb 2026 04:33:54 +0000

Trainer: Mr.Nantha
Day-7

Overview

Today’s session focused on three important topics in Java: default values, constructors, and object initialization.

Constructors

Constructors are special methods used to create and initialize objects in Java. They allow developers to set up an object’s initial state when it is instantiated.

Important Rules

(1) Constructor name must be same as class name.

(2) It does not have a return type (not even void).

(3) It runs automatically when object is created.

Example
class Student {

String name;

// Constructor
Student(String n) {
    name = n;
}

public static void main(String[] args) {
    Student s1 = new Student("Arjun");
    System.out.println(s1.name);
}

}

Output:

Arjun

What Happens Here?
Student s1 = new Student("Arjun");

✔ Memory is created in Heap
✔ Constructor runs automatically
✔ Variable name gets initialized

Default Values in Java

When we create an object, Java automatically assigns default values to instance variables if we do not initialize them.

Default Values for Instance Variables:

|Data Type| |Default Value|

Default Values

Default values refer to the initial values assigned to fields or variables when an object is created, especially if no explicit value is provided.

Object Initialization

Object initialization is the process that occurs when an object is created, involving the assignment of default values and the execution of constructors to prepare the object for use.

Default Values vs Constructor Initialization

  |Default Values|                          |Constructor|

Object Initialization in Java

Object Initialization means assigning values to the variables of an object when it is created.

When we create an object using the new keyword, memory is allocated in the Heap. Then the object’s variables must be initialized with values.

Why Object Initialization is Important?

Prevents null or default value issues

Makes object ready to use

Improves code clarity

Example: Which I practiced in class today for Constructor.

package Constructor;

public class School {

    int id;

    //Constructor
    School(int stdId)
    {
        this.id = stdId;
    }



    public static void main(String[] args) {

        School yogesh = new School (101);
        System.out.println(yogesh.id);

    }
}

Output:
101

Key Takeaways

• Constructors are special methods that are used to create and initialize objects, allowing developers to set up the initial state of an object upon instantiation.

• Default values are the initial values assigned to fields or variables in Java when no explicit value is provided.

• Object initialization involves both the assignment of default values and the execution of constructors, ensuring that objects are properly prepared for use in Java programs.

Understanding Operators in Java

scindia bethuraj — Wed, 25 Feb 2026 15:38:00 +0000

Trainer: Mr.Nantha
Day 6

Overview of Java Operators

What are Operators in Java?

Operators are special symbols used to perform operations on variables and values.

In simple words, operators make it possible to carry out calculations, comparisons, and logical operations in a program.

After understanding how to declare and initialize variables, it is essential to explore their practical applications. Gaining proficiency in the operators of the Java programming language serves as an important next step. Operators are specialized symbols that execute defined operations on one, two, or three operands, subsequently yielding a result.

Example
int a = 10;
int b = 5;
int sum = a + b;

Here,

is an operator It adds a and b.

Types of Operators in Java

Arithmetic Operators

The Java programming language provides operators that perform addition, subtraction, multiplication, and division. There's a good chance you'll recognize them by their counterparts in basic mathematics. The only symbol that might look new to you is "%", which divides one operand by another and returns the remainder as its result.

Operator	Meaning
	+
	-
	*
	/
	%

Example:

int result = 10 % 3;

The Unary Operators

The unary operators require only one operand; they perform various operations such as incrementing/decrementing a value by one, negating an expression, or inverting the value of a Boolean.

|Operator| |Description|

|+| |Unary plus operator; indicates positive value (numbers are
positive without this, however)|
|-| |Unary minus operator; negates an expression|
|++| |Increment operator; increments a value by 1|
|--| |Decrement operator; decrements a value by 1|
|!| |Logical complement operator; inverts the value of a boolean|

The increment/decrement operators can be applied before (prefix) or after (postfix) the operand. The code result++; and ++result; will both end in result being incremented by one. The only difference is that the prefix version (++result) evaluates to the incremented value, whereas the postfix version (result++) evaluates to the original value. If you are just performing a simple increment/decrement, it doesn't really matter which version you choose. But if you use this operator in part of a larger expression, the one that you choose may make a significant difference.

What is Increment Operator?

++ is called the increment operator.
It increases the value of a variable by 1.

Example:

int a = 5;
a++; // now a becomes 6

re-Increment (++a)

👉 Value is increased first, then used.

Example:
int a = 5;
int b = ++a;

Step-by-step:

a becomes 6

b gets 6

Final Values:

a = 6
b = 6
Post-Increment (a++)

👉 Value is used first, then increased.

Example:
int a = 5;
int b = a++;

Step-by-step:

b gets 5

then a becomes 6

Final Values:

a = 6
b = 5

Easy Trick to Remember

Pre = Change first
Post = Print first

Equality, Relational, and Conditional Operators
The Equality and Relational Operators
The equality and relational operators determine if one operand is greater than, less than, equal to, or not equal to another operand. The majority of these operators will probably look familiar to you as well. Keep in mind that you must use "==", not "=", when testing if two primitive values are equal.

|==| |equal to|
|!=| |not equal to|
|> | |greater than|
|>= | |greater than or equal to|
|< | |less than|
|<= | |less than or equal to|

The Conditional Operators
The && and || operators perform Conditional-AND and Conditional-OR operations on two boolean expressions. These operators exhibit "short-circuiting" behavior, which means that the second operand is evaluated only if needed.

&& Conditional-AND
|| Conditional-OR

TASK :

int a = 5;
int b = 7;
int c = 10;

int result = a++ + a-- - --a + --b - ++c -  --c;

What is the result?
a++
Post-increment → use a first, then increment

Value used = 5

Then a becomes 6

So first part = 5

a = 6

a--

Post-decrement → use a first, then decrement

Value used = 6

Then a becomes 5

Second part = 6

a = 5

--a

Pre-decrement → decrement first, then use

a = 4

Value used = 4

Third part = 4

a = 4
--b

Pre-decrement → decrement first, then use
**
b = 6**

Value used = 6

Fourth part = 6

b = 6

++c

Pre-increment → increment first, then use

c = 11

Value used = 11

Fifth part = 11

c = 11
--c

Pre-decrement → decrement first, then use

c = 10

Value used = 10

Sixth part = 10

c = 10

Combine Everything

The expression:

result = a++ + a-- - --a + --b - ++c - --c

Substitute values used in order:

result = 5 + 6 - 4 + 6 - 11 - 10

5 + 6 = 11

11 - 4 = 7

7 + 6 = 13

13 - 11 = 2

2 - 10 = -8

Final Values of Variables

After the expression:

a = 4
b = 6
c = 10

Key Takeaways – Operators & Increment/Decrement

Operators are symbols used to perform operations on variables and values.

Arithmetic, Relational, Logical, Assignment, Unary are main types of operators in Java.

Increment (++) and Decrement (--) can be prefix or postfix:

Prefix (++a / --a) → value changes first, then used.

Postfix (a++ / a--) → value used first, then changes.

Complex expressions with multiple operators should be solved step by step, tracking variable values after each operation.

Understanding operators is crucial for automation logic, loops, conditions, and interview questions.

Day 5 of My Selenium Java Class – Variables, String Methods & Static vs Instance

scindia bethuraj — Wed, 25 Feb 2026 04:08:47 +0000

Trainer: Mr.Nantha
Day 5
Session Overview
Today’s session focused on strengthening core Java concepts that are extremely important for automation testing and interviews.

Topics Covered

• Variables & Types of Variables: We explored the concept of variables in Java, including the different types that are commonly used.

• Important String Methods: The session included a review of key String methods, emphasizing their significance and usage in Java programming.

• Static vs Instance Variables: We discussed the distinction between static and instance variables, clarifying their roles and how they differ in Java applications.

Variables in Java
In Java, a variable acts as a container that holds data during program execution. Variables allow you to store, modify, and retrieve information as your code runs.

Example:

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

In these examples:

• The words int and String are data types that specify what kind of data the variable can store.
• Age and name are the variables that store values of type int and String respectively.

Types of Variables in Java

Local Variable • Declared inside a method. • Accessible only within the method where it is declared. • Does not have a default value; you must initialize it before use.

Example:

void display() {
int number = 10;
}

Instance Variable

• Declared inside a class but outside any method.
• Each object of the class has its own copy of the variable.
• Accessing the variable requires creating an object of the class.

Example:

class Student {
String name;
}

Static Variable • Declared using the static keyword inside a class. • Shared among all objects of the class. • Memory for the variable is allocated only once, regardless of how many objects are created.

Example:

class Student {
static String college = "GRD College";
}

All objects of the Student class share the same value for the college variable.

Important String Methods

In automation testing with Selenium, Strings are used frequently for storing locators, validating data, and working with URLs. Mastering String methods is essential for efficient Java programming.
Some commonly used String methods include:

length()

Returns the number of characters in a String.

Example:
String name = "Java";
System.out.println(name.length());

toUpperCase() / toLowerCase()

Converts all characters to upper or lower case.
Example:
name.toUpperCase();
name.toLowerCase();

equals()

Compares two strings for equality.

Example:
name.equals("Java");

contains()

Checks if a substring exists within the String.

Example:
name.contains("av");

charAt()

Returns the character at a specific index.

Example:
name.charAt(0); // J

substring()

Extracts a part of the String from the given indices.

Example:
name.substring(1,3);

*Static vs Instance Variables *

Understanding the difference between static and instance variables is a common interview topic. The table below summarizes the key differences:

Instance Variable Static Variable

Belongs to object Belongs to class
Requires object creation No object needed
Each object has a separate copy Shared among all objects
Memory allocated multiple times Memory allocated once

Example:
class Example {
int instanceVar = 10;
static int staticVar = 20;
}

If you create three objects of the Example class:

• Each object gets its own copy of instanceVar (three copies in total).
• There is only one shared copy of staticVar for all objects.

Key Takeaways
• Variables are containers for storing data in a program.
• Java supports three main types of variables: Local, Instance, and Static.
• Mastering String methods is crucial for automation testing and interview success.
• Static variables are shared among all objects, while instance variables are unique to each object.

Example

Step 1: Create a file named:
StudentDemo.java

Step 2: class StudentDemo {

// Instance variable
String name;

// Static variable
static String college = "GRD College";

public static void main(String[] args) {

    // Creating object (instance)
    StudentDemo s1 = new StudentDemo();
    s1.name = "John";

    // Using String methods
    System.out.println("Name length: " + s1.name.length());
    System.out.println("Uppercase: " + s1.name.toUpperCase());

    // Printing instance and static variables
    System.out.println("Student Name: " + s1.name);
    System.out.println("College Name: " + college);
}

}

Step 3: Compile the Program (Using Command Line)

Open Command Prompt
Navigate to the folder where the file is saved:
cd Desktop
Compile the file:
javac StudentDemo.java

If there is no error, it will create:

StudentDemo.class

If there is an error, it will show the line number.

Step 4: Run the Program
Now type:
java StudentDemo

Expected Output
Name length: 4
Uppercase: JOHN
Student Name: John
College Name: GRD College

Memory Management in Java
**
Built-In Memory Management System
**
Java has a built-in memory management system that is designed to efficiently handle data storage and cleanup during program execution. This automatic process ensures that memory is allocated and released as needed, reducing the risk of memory leaks and improving overall program stability.

Importance in Automation Scripts

Understanding Java’s memory management system is essential for writing efficient Selenium or Playwright automation scripts. A solid grasp of these concepts helps developers optimize their scripts for better performance and reliability, making test automation more effective.

*How Java Memory is Organized
*
Java divides memory into two main areas:

Memory Area - Purpose

Stack Memory - Stores local variables and method calls. Memory is temporary and automatically removed when a method ends.

Heap Memory - Stores objects and instance variables. Memory is shared among objects and managed by Garbage Collector (GC).

Stack Memory

Stores primitive local variables and references to objects.

Follows Last In First Out (LIFO) principle.

Memory is automatically released when the method finishes.

Static vs Instance Variables in Memory

Variable Type Memory Location Notes

Instance Variable Heap Each object gets its own copy

Static Variable Method Area (part of heap) Shared among all objects

Garbage Collector (GC)

Java automatically removes objects that are no longer referenced to free up memory.

Helps prevent memory leaks

Reduces programmer effort

Memory Flow Example in a Program
class Student {
String name; // Instance variable (Heap)
static String college = "GRD College"; // Static variable (Method Area)

void display() {
    int age = 20;  // Local variable in stack
    System.out.println(name + " - " + age);
}

}

public class MemoryDemo {
public static void main(String[] args) {
Student s1 = new Student(); // Object in Heap
s1.name = "John";
s1.display();
}
}

Memory Map:

s1 → reference in stack, object in heap

name → stored in heap

age → stored in stack temporarily

college → stored in method area (shared among objects)

Key Takeaways

• Variables are containers for storing data in a program.

• Java supports three main types of variables: Local, Instance, and Static.

• Mastering String methods is crucial for automation testing and interview success.

• Static variables are shared among all objects, while instance variables are unique to each object.

Stack Memory

Stores local variables and method calls.

Memory is temporary and released automatically when the method ends.
Heap Memory

Stores objects and instance variables.

Shared among all objects. Memory is managed by Garbage Collector.
Instance vs Static Variables in Memory

Instance variables → stored in heap, each object has its own copy.

Static variables → stored in method area, shared among all objects.
Garbage Collector (GC)

Automatically removes unreferenced objects.

Prevents memory leaks and reduces manual memory management.

An Overview of JDK, JRE, JVM & JIT

scindia bethuraj — Wed, 25 Feb 2026 03:24:30 +0000

Trainer: Mr. Nantha
DAY 2

This section focuses on the core components essential for running and developing Java applications: the Java Development Kit (JDK), Java Runtime Environment (JRE), Java Virtual Machine (JVM), and Just-In-Time (JIT) . Each plays a crucial role in the execution and performance of Java programs.

What is JDK?

JDK (Java Development Kit) is a software package used to develop Java applications.

In simple terms, the JDK helps us write, compile, and run Java programs.

• It provides the tools needed to create and execute Java applications, including a compiler and other utilities.
• The JDK is used to convert a file with the .java extension (which is human-readable) into a .class file.
• The .class file, also known as bytecode, is not readable by humans.
• A key advantage of the .class file is its platform independence; it can be executed on any operating system.

What is JRE?

JRE (Java Runtime Environment) is used to run Java programs. It provides the resources required for executing Java applications, but does not include development tools for writing or compiling code.

The JRE contains the following components:
• JVM (Java Virtual Machine), which interprets and executes Java bytecode.
• Supporting libraries that provide core functionality for Java applications.
• Runtime files needed for program execution.
The JRE does not include a compiler, so it cannot be used to develop or compile Java programs—only to run them.

What is JVM?
JVM (Java Virtual Machine) is the engine that runs Java programs.
Example:
When we write a Java file:
Sample.java
Compile using JDK
javac Sample.java
This creates:
Sample.class

How Java Code Is Executed

Step 1: Bytecode Generation
After you write and compile a Java program, the compiler generates a .class file. This file contains bytecode, which is an intermediate, platform-independent code.

Step 2: Execution by JVM
The Java Virtual Machine (JVM) reads this bytecode and converts it into machine code that your computer's processor can understand and execute.

Step 3: Platform Independence
By using bytecode and the JVM, Java achieves platform independence. This means you can write your code once, and it will run on any operating system that has a compatible JVM—fulfilling Java's promise of "Write Once, Run Anywhere."

What is JIT?

JIT (Just-In-Time Compiler) is an essential component of the Java Virtual Machine (JVM). It plays a significant role in enhancing the performance of Java applications.

The JIT compiler works by converting bytecode into machine code at runtime. This means that, as the program runs, the JIT compiles sections of bytecode into native machine code, which the computer's processor can execute directly.

Instead of interpreting the code line by line each time it runs, the JIT identifies code that is used frequently and compiles it into native machine code. This process allows the program to execute these portions much more quickly in subsequent runs.

By performing these optimizations at runtime, the JIT compiler significantly improves the execution speed of Java programs.

How They Work Together
1️⃣ We write code → Sample.java
2️⃣ JDK compiles it → Sample.class
3️⃣ JRE provides environment to run
4️⃣ JVM executes bytecode
5️⃣ JIT optimizes performance

Simple Difference Table
Component Purpose
JDK Develop + Compile + Run
JRE Run Java programs
JVM Executes bytecode
JIT Improves performance

Key Takeaways from Day 2

On Day 2, I focused on understanding the essential components of the Java ecosystem. Here are my main takeaways:

JDK (Java Development Kit)
The JDK is specifically designed for development purposes. It provides all the necessary tools, libraries, and resources required to build Java applications.

JRE (Java Runtime Environment)
The JRE is used for running Java programs. It contains the libraries and components needed to execute Java applications, but does not include development tools.

JVM (Java Virtual Machine)
The JVM is responsible for executing bytecode. It acts as the runtime engine that interprets and executes the compiled Java code.

JIT (Just-In-Time Compiler)
The JIT compiler improves performance by converting bytecode into machine code during runtime, allowing for faster execution of Java programs.
Platform Independence

Day by day, I’m building a strong Java foundation before moving deeper into Selenium and Playwright automation.

Introduction to Selenium Java and Playwright: First Session

scindia bethuraj — Tue, 17 Feb 2026 21:29:20 +0000

*Trainer : Mr. Nantha *
Day 1

Overview of the First Module

Today marked the beginning of my Selenium Java class. The session offered valuable information and inspired me to dive deeper into the subject. I felt encouraged and motivated throughout, as the trainer emphasized the importance of documenting our learning through blog posts, rather than traditional note-taking. This approach not only helps reinforce understanding but also allows us to share knowledge with a wider audience.
The trainer also provided an overview of the modules we will cover in the first session, including key Java concepts such as JDK, JRE, JVM, and JIT. We learned how to compile and run Java programs using the command line, and received guidance on downloading the JDK. Overall, the class set a strong foundation for our journey with Selenium Java and Playwright.

Understanding Java: Definition and Ownership

What is Java?

Java is a programming language used to write instructions for computers. It enables developers to create software applications that can run on a variety of platforms, making it a versatile and widely-used language in the technology industry.

Origin and Ownership of Java

Java was originally developed by Sun Microsystems in 1995 and is now owned by Oracle Corporation. This transition of ownership has helped Java continue to evolve while remaining a critical tool for developers worldwide.
**
Understanding JDK**

For today’s session, the focus was on JDK.

What is JDK?

JDK stands for Java Development Kit.

In simple terms:

JDK is a software package that helps you write, compile, and run Java programs on your computer.

How Java Compilation Works

When we write a Java file:
• The file is saved with the extension .java
When we compile it using the command line:
java Sample.java

Two things can happen:

(1) IF THERE IS AN ERROR - The compiler shows an error message and indicates the line number where the mistake occurred.
(2) IF THERE IS NO ERROR - A .class file is generated.
This .class file is the bytecode that the Java Virtual Machine (JVM) executes.

Key Learning from Day 1

Understanding the significance of technical blogging
Exploring the fundamental structure of Java
Recognizing JDK's function in Java development
Learning how Java files undergo compilation
Setting up software needed for automation testing
This is only the start, and I'm eager to explore Java, Selenium, and Playwright more thoroughly in the next sessions.