Forem: MANOJ K

Java String Methods:

MANOJ K — Fri, 27 Mar 2026 07:38:22 +0000

String trim() Method

The trim() method is used to remove unwanted spaces from the beginning and end of a string.
This method does not change the original string.

//Remove trailing space (password issue)

String pwd = " Admin123 ";
pwd = pwd.trim(); 
System.out.println(pwd);

output:
Admin123

String equalsIgnoreCase() Method

The equalsIgnoreCase() method compares two strings, ignoring lower case and upper case differences.
This method returns true if the strings are equal, and false if not.

Compare username safely (ignore case)   

String s1 = "Vijay";
String s2 = "vijay";
System.out.println(s1.equalsIgnoreCase(s2));

output:
true

== vs equals() in Java String

== is a comparison operator used to check whether two references point to the same memory.
equals() is a String method used to check whether two strings have the same content (value).

== vs equals()  

String s1 = "Java";
String s2 = new String("Java");
System.out.println(s1 == s2);         false (memory check)
System.out.println(s1.equals(s2));    true (value check)

contains() method:

The contains() method is used to check whether a string contains a specified sequence of characters.
Returns true if the characters exist and false if not.

Check email contains '@' and '.'

String email = "test@gmail.com";                
if(email.contains("@") && email.contains(".")){                
  System.out.println("Valid");              
}               
else {              
  System.out.println("invalid");                
}

parseInt() method

Integer.parseInt() method is used to convert a String into an integer (int).

Convert String to int   

String num = "12345";       
int n = Integer.parseInt(num);
System.out.println(n+10);

output:
12355

String split() Method:

The split() method is used to divide a string into parts based on a delimiter (separator) and returns an array of strings.

Count "Java" occurrences

String str = "Java is easy. Java is powerful.";         
int count = 0;          
String[] words = str.split(" ");            
for(String w : words){                  
if(w.equals("Java")) count++;           
}           
System.out.println(count);

output:
2

Reverse String in Java:

String reverse means changing the order of characters from last to first.

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

        String str="Java";
        String rev="";

        for(int i=str.length()-1;i>=0;i--){
            rev=rev+str.charAt(i);
        }

        System.out.println("Reversed: "+rev);

    }
}

Check palindrome:

A palindrome is a word, number, or string that reads the same forward and backward.

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

        String str = "madam";
        String rev = "";

        for(int i=str.length()-1;i>=0;i--){
            rev += str.charAt(i);
        }

        if(str.equals(rev)){
            System.out.println(str+" is Palindrome");
        }
        else{
            System.out.println(str+" is Not Palindrome");
        }
    }
}

Remove duplicate characters:

This program removes duplicate characters from a string and keeps only unique characters.

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

        String str = "aabbccdd";
        String result = "";

        for(int i=0;i<str.length();i++){
            char c=str.charAt(i);

            if(result.indexOf(c)==-1){
                result+=c;
            }
        }

        System.out.println(result);
    }
}

Extract message from log:

This program extracts the actual message from a log string by using split() and trim().

String log = "ERROR: File not found";               
String result =log.split(":"[1].trim();             
System.out.println(result);

CSV Extract:

This program extracts values from a CSV (Comma Separated Values) string using the split() method.

String data = "Vijay,25,Chennai";
String[] arr = data.split(",");

System.out.println("Name: " + arr[0]);          
System.out.println("Age: " + arr[1]);           
System.out.println("City: " + arr[2]);

What is a string in Java?

MANOJ K — Thu, 26 Mar 2026 16:29:31 +0000

What is a string in Java?

In Java, a String is an object that represents an immutable sequence of characters. The String class is part of the java.lang package, which is automatically imported into all Java programs.
Strings are used for storing text.
A String variable contains a collection of characters surrounded by double quotes (""):

Creating Strings in Java
String Literal:

A string literal is a string created using double quotes. These strings are stored in the String Constant Pool to save memory and reuse objects.

String s1 = "Hello";

Using new Keyword:

When we create a string using the new keyword, Java creates a new object in heap memory even if the same value already exists.

String s2 = new String("Hello");

Key Characteristic's **
**1. Strings are Immutable

Once a String object is created, its value cannot be changed.

String s = "Hello";
s.concat(" World");
System.out.println(s);

Output:
Hello

2. String is a Class (not primitive)

String is an object of String class from java.lang package.

String name = "Manoj";

3. Strings are Thread Safe

Because they are immutable, they are automatically thread safe.

Reference
https://docs.oracle.com/javase/tutorial/java/data/strings.html
https://www.geeksforgeeks.org/java/strings-in-java/
https://docs.oracle.com/javase/8/docs/api/java/lang/String.html

Class in Java::

MANOJ K — Sat, 07 Feb 2026 05:49:01 +0000

1. class:

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

2.Use the class keyword:

A class must be declared using the class keyword.

class MyClass {
}

3.Class name rules:

The class name must start with a letter (A–Z or a–z).
It cannot start with a digit.
It must not contain spaces.
Special characters are not allowed except _ and $.
Java reserved keywords cannot be used as class names.

4.Naming convention:

By Java convention, the class name should start with a capital letter, and if it contains multiple words, each word should start with a capital letter.

class StudentDetails

5.Curly braces are mandatory:

The body of a class must be enclosed within curly braces { }.

class Car {
    // fields and methods
}

6.One public class per file:

A .java file can contain only one public class.

7.File name rule:

If a class is declared as public, the file name must be the same as the public class name.

public class Student {
}

8.Access modifiers:

A class can have an access modifier like public or no modifier (default).
Top-level classes cannot be private or protected.

9.main() method is required to run:

To execute a Java program, the class must contain the main() method.

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

10.Multiple classes in one file:

Multiple classes can be defined in a single file, but only one can be public.

Object-Oriented Programming (OOPS):

MANOJ K — Thu, 05 Feb 2026 13:32:36 +0000

Object Oriented Programming (oops):

Object-Oriented Programming (OOP) is a programming approach in which software is designed using objects that represent real-world entities, and these objects contain data (fields) and behavior (methods).

Class:

Blueprints or templates for creating objects that define the structure and behavior of data.

Objects:

An object is a real-time instance of a class that represents a real-world entity and contains data (variables) and behavior (methods).
An object is an instance of a class in Object-Oriented Programming.

Inheritance:

Inheritance is an Object-Oriented Programming concept in which one class (child/subclass) acquires the properties and methods of another class (parent/superclass).
Inheritance supports code reusability and establishes a parent–child relationship between classes.

Encapsulation:

Encapsulation is an Object-Oriented Programming concept that bundles data (variables) and methods into a single unit (class) and restricts direct access to the data.

Polymorphism:

Polymorphism is an Object-Oriented Programming concept where the same method or action behaves differently based on the object that is calling it.
Polymorphism improves flexibility by allowing the same method name to perform different tasks.

Abstraction:

Abstraction is an Object-Oriented Programming concept that hides implementation details and shows only the essential features of an object.

Reference:

https://www.geeksforgeeks.org/dsa/introduction-of-object-oriented-programming/
https://www.w3schools.com/JAVA/java_oop.asp

Java Features::

MANOJ K — Thu, 05 Feb 2026 05:47:21 +0000

Features of Java:

Java is a high-level, object-oriented programming language. It is known for its platform independence, reliability, and security. It follows one principle, that is "Write Once, Run Anywhere" principle.

## Simple:

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

## Object Oriented :

Java is a pure object-oriented language. It supports core OOP concepts like,
```
Class
```
```
Objects
```
```
Inheritance
```
```
Encapsulation
```
```
Abstraction
```
```
Polymorphis
```

## Platform Independent :

Java is platform-independent because of Java Virtual Machine (JVM).
When we write Java code, it is first compiled by the compiler and then converted into bytecode (which is platform-independent).
This byte code can run on any platform which has JVM installed.

## Interpreted :

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

5. Scalable :

Java can handle both small and large-scale applications. Java provides features like multithreading and distributed computing that allows developers to manage loads more easily.

6.## Memory Management:

Memory management in Java is automatically handled by the Java Virtual Machine (JVM).
Java garbage collector reclaim memory from objects that are no longer needed.
Memory for objects are allocated in the heap
Method calls and local variables are stored in the stack.

Java Architecture::

MANOJ K — Tue, 03 Feb 2026 12:48:11 +0000

The Java Development Kit (JDK):

The Java Development Kit (JDK) is a software development environment used to develop, compile, debug, and package Java applications.
It includes the Java Runtime Environment (JRE), the Java Virtual Machine (JVM), and development tools such as the Java compiler (javac) and debugger.
The JDK is used for building,testing,and running java applications it's essential for developers to;

write java code.
compile java code into bytecode.
run java applications.

JRE (Java Runtime Environment):

JRE (Java Runtime Environment) is a software package that provides the environment required to run Java applications.
It includes the Java Virtual Machine (JVM) and core Java class libraries, but it does not include development tools like the compiler.

JVM (Java Virtual Machine):

JVM (Java Virtual Machine) is a virtual machine that executes Java bytecode and enables Java programs to run on any operating system without modification.
It converts Java bytecode into machine-specific instructions and manages memory, security, and execution.

Reference:

JavaScript Interview Question::

MANOJ K — Fri, 21 Nov 2025 07:23:35 +0000

1. Difference Between HTML and DOM

HTML (HyperText Markup Language)

HTML is the static markup code written by the developer.
It is the source document loaded from a file (index.html) or server.
It does not change unless the file is edited manually.
The browser reads HTML first to build the page structure.

Example:

<p id="msg">Hello</p>

This is the real markup inside the file.

DOM (Document Object Model)

DOM is the in-memory representation of the HTML created by the browser.
It behaves like a tree of objects (nodes).
The DOM can change dynamically using JavaScript (add/remove/change elements).
What you see in DevTools is the DOM, not the original HTML file.

Example:

document.getElementById("msg").textContent = "Hi!";

This changes the DOM, not the HTML file.

2.Difference between var, let and const keywords in JavaScript

var:

Declares variables with function or global scope and allows re-declaration and updates within the same scope.

Example:

var x = 10;
var x = 20; // allowed

let:

Declares variables with block scope, allowing updates but not re-declaration within the same block.

Example:

let y = 10;
y = 20; // allowed
let y = 30; // ❌ not allowed

const:

Declares block-scoped variables that cannot be reassigned after their initial assignment.

Example:

const user = { name: "A", age: 20 };
user.age = 21; // ✔ allowed (modifying object)
user = {};     // ❌ not allowed

3. Function Declaration vs Function Expression

Function Declaration

Also called function statement.
Defined using the function keyword with a name.
Hoisted completely, so it can be called before it is defined.
More suited for defining functions you want available globally in a scope.

Example:

sayHello(); // ✔ Works (hoisted)

function sayHello() {
  console.log("Hello");
}

Function Expression

A function stored inside a variable.
Can be named or anonymous.
Not fully hoisted → the variable is hoisted, but not the function.
Cannot be called before the line where it is defined.

Example:

sayHi(); // ❌ Error: sayHi is not a function

var sayHi = function () {
  console.log("Hi");
}

4. == vs ===

== (Loose Equality)

Compares values only.
Performs type coercion if types are different.
Converts operands to the same type before comparing.

Example:

0 == "0";       // true (string converted to number)
false == 0;     // true (boolean converted to number)
null == undefined; // true

=== (Strict Equality)

Compares both value and type.
No type coercion is done.
Safer and recommended in most cases.

Example:

0 === "0";      // false (number !== string)
false === 0;    // false (boolean !== number)
null === undefined; // false

5.Difference Between Class and Object in JavaScript

Class:

A blueprint or template for creating objects
Defines properties and methods
Does not occupy memory until an object is created
Introduced in ES6
Example: class Car {}

Object:

A real instance created from a class
Occupies memory
Contains actual data values
Created using a class or object literals
Example: const car1 = new Car();

Example:

class Car {
  constructor(name, model) {
    this.name = name;
    this.model = model;
  }
}

const car1 = new Car("BMW", "X5");

Car → Class (template)
car1 → Object (instance)

HTML::

MANOJ K — Thu, 25 Sep 2025 17:32:09 +0000

HTML Tags

What they are:

Special keywords enclosed in angle brackets (< >) that tell the browser how to interpret content.

How they work:

- Usually come in pairs:
  - Opening tag  <p>
  - Closing tag  </p>
- Closing tags always start with a forward slash /.

Purpose:

Mark the start and end points of an element.

HTML Elements

What they are:

A complete structure that includes the opening tag, the content inside it, and the closing tag.

How they work:

Start tag + Content + End tag = Element

Purpose:

Elements are the actual building blocks of a webpage.

Example:

<p>This is a paragraph.</p>


-  <p> → opening tag
-  This is a paragraph. → content
-  </p> → closing tag
-  Together, they form a paragraph element.

Reference:
https://www.tutorialspoint.com/html/html_elements.html
https://www.w3schools.com/html/html_elements.asp

HTML & CSS :

MANOJ K — Wed, 24 Sep 2025 14:19:39 +0000

****What is HTML?

HTML stands for Hyper Text Markup Language
HTML is the standard markup language for creating Web pages
HTML describes the structure of a Web page
HTML consists of a series of elements
HTML elements tell the browser how to display the content
HTML elements label pieces of content such as "this is a heading", "this is a paragraph", "this is a link", etc.

 <!DOCTYPE html>
<html>
<head>
<title>Page Title </title>
</head>
<body>

<h1>Heading</h1>
<p>paragraph.</p>

</body>
</html>

What is CSS?

CSS is the language we use to style a Web page.

CSS stands for Cascading Style Sheets.
CSS describes how HTML elements are to be displayed on screen, paper, or in other media.
CSS saves a lot of work. It can control the layout of multiple web pages all at once.
External stylesheets are stored in CSS files.

<!DOCTYPE html>
<html>
<head>
<style>
body {
  background-color: lightblue;
}

h1 {
  color: white;
  text-align: center;
}

p {
  font-family: verdana;
  font-size: 20px;
}
</style>
</head>
<body>

<h1>My First CSS Example</h1>
<p>This is a paragraph.</p>

</body>
</html>

Referance

https://www.w3schools.com/html/html_intro.asp
https://www.geeksforgeeks.org/css/css-cheat-sheet-a-basic-guide-to-css/

Parameters and arguments in java

MANOJ K — Sun, 14 Sep 2025 17:21:32 +0000

Arguments

Arguments are the actual values or data that you pass to a method when calling it.
They are assigned to the corresponding parameters when the method executes.
In short, arguments provide the input that a method needs to work with.

class Example {
    void add(int a, int b) {
        System.out.println("Sum = " + (a + b));
    }

    public static void main(String[] args) {
        Example obj = new Example();

        // 10 and 20 are arguments
        obj.add(10, 20);
    }
}



Here, 10 and 20 are arguments passed to the method add().

Parameters

Parameters are variables declared inside the method definition.

They act as placeholders to receive the values (arguments) when the method is called.

In simple terms, parameters are like input variables for a method.

class Example {
    void add(int a, int b) {   // 'a' and 'b' are parameters
        System.out.println("Sum = " + (a + b));
    }
}


Here, a and b are parameters of the add() method.

Parameters = variables inside the method definition.

Arguments = actual values you pass when calling the method.

This and Super Keyword::

MANOJ K — Thu, 11 Sep 2025 17:45:27 +0000

this keyword:

What is this keyword in Java?

this refers to the current object of the class.
this refers to the instance variable of the current object.

2.When do we use this keyword?

__To refer to the current instance variable

If local variable and instance variable have the same name, this helps avoid confusion.

__To call the current class method

Inside a class, we can use this to call another method of the same class.

__To call another constructor in the same class (Constructor Chaining)

this() is used to call another constructor of the same class.

3.How is this keyword used in Java?

this.variable → access current object variable
this.method() → call a method of same class
this() → call another constructor in same class

4.Why do we use this keyword?

To avoid confusion between local variables and instance variables.
To reuse constructors (constructor chaining).
To make code cleaner and more readable.
To refer to current object in methods, especially in OOP concepts
like passing objects, builder patterns, etc.

5.where we use this Keyword java?

in constructors --- to call another constructor
in instance method --- to access Variables/method of the same object.
when passing the Current Object --- as a Parameter

Super keyword:

1.what is Super keyword in Java?

The Super keyword is refer to the Immediate Parent class object.
allowing a Subclass to access its Parent's members.
The Super keyword refers to Superclass (parent) object.

2.when we use Super Keyword in java?

Super Keyword is used to call Superclass method and to access the Superclass Constructor.
when a child class overrides a method but you still need the parent
class you use super keyword.
when Parent and child class Variables have the same name we use Super.

3.How it will be used?

super.variable ---- access parent class variable.
super.method() ---- call parent class method.
super() ---- call parent class constructor (must be first statement).

4.where we use super keyword in java?

__To access parent class variables

used Inside a Child Class Construtor.
must be the first statement in the Constructor.

__To access Parent Class Variables

IF both Parrent and child have a Variable with the Same name we use super to access the Parent Version.

__ Tο access Parent class methods

→if a method is overridden in child Class,we can still call the parent's method using super.

5.why we use super Keyword?

__To avoid Variable shadowing.

If the child class has a Variable with the Same name as the Parent the child's variable hides the Parent's.

→using Super.VariableName, we can still access the parent's version.

__To call the Parent's method when overridden

when the child overrides a method, Sometimes we still want to use the parent's method.
super.methodName() lets us call the parent's implementation.

Super Keyword ::

MANOJ K — Wed, 10 Sep 2025 09:38:55 +0000

Super Keyword :

The super keyword in Java is used to refer to the immediate parent class object.
The super keyword refers to superclass (parent) objects.
It is used to call superclass methods, and to access the superclass constructor.
The most common use of the super keyword is to eliminate the confusion between superclasses and subclasses that have methods with the same name.
To understand the super keyword, you should have a basic understanding of Inheritance and Polymorphism.

class Animal {
    String name = "Animal";

    void sound() {
        System.out.println("Animal makes a sound");
    }
}

class Dog extends Animal {
    String name = "Dog";

    void sound() {
        System.out.println("Dog barks");
    }

    void show() {
        // Access parent variable
        System.out.println("Parent name: " + super.name);

        // Call parent method
        super.sound();
    }
}

public class Main {
    public static void main(String[] args) {
        Dog d = new Dog();
        d.show();
    }
}


OUTPUT:
Parent name: Animal
Animal makes a sound
---------------------------------------------

super.name → gets the parent class variable.

super.sound() → calls the parent class method.

Reference:

https://www.datacamp.com/doc/java/super
https://www.w3schools.com/java/ref_keyword_super.asp
https://www.scholarhat.com/tutorial/java/super-keyword-in-java