DEV Community: Indumathy

JavaScript Operators

Indumathy — Mon, 30 Mar 2026 14:15:20 +0000

What are Operators?
Operators are symbols used to perform operations on values or variables.
Example:
let result = 5 + 3;
Here, '+' is an operator that adds two numbers.

Types of JavaScript Operators

Arithmetic Operators
Assignment Operators
Comparison Operators
Logical Operators
String Operators

1. Arithmetic Operators

Used for mathematical calculations.

Addition (5 + 3)
Subtraction (5 - 3)
Multiplication (5 * 3) / Division (10 / 2) % Modulus (10 % 3)

Increment / Decrement:

x++ Post Increment
++x Pre Increment
x-- Post Decrement
--x Pre Decrement

Example:

let x = 5;
x++;
console.log(x);

Output: 6

2. Assignment Operators

Used to assign values to variables.

= x = 5
+= x += 5 (x = x + 5)
-= x -= 5 (x = x - 5)
*= x *= 5 (x = x * 5)
/= x /= 5 (x = x / 5)

Example:
let x = 10;
x += 5;
console.log(x);

Output: 15

3. Comparison Operators

Used to compare two values. Result is true or false.

== 5 == '5' → true
=== 5 === '5' → false
!= 5 != 3 → true

5 > 3 → true
< 5 < 3 → false
= 5 >= 5 → true
<= 5 <= 8 → true

Note:
== checks value only
=== checks value and data type

4. Logical Operators

Used to combine or check conditions.

&& AND
|| OR
! NOT

Example AND:(returns true only if both conditions true)

let age = 20;
if(age > 18 && age < 60){
console.log('Eligible for job');
}
Output: Eligible for job

Example OR:(returns true if atleast one condition passed)

let marks = 35;
if(marks >= 40 || marks >= 35){
console.log('You passed');
}

Output: You passed

5. String Operator

Used to combine strings.

Example:
let first = 'Hello';
let second = 'World';
console.log(first + ' ' + second);

Output: Hello World

Conclusion
JavaScript operators are fundamental in programming. They help perform calculations, assign values, compare data, and combine conditions. Understanding operators is an important step for beginners learning JavaScript.

Exception handling scenario

Indumathy — Mon, 16 Mar 2026 13:42:04 +0000

1. Division Program :
public class DivisionTest {
public static void main(String[] args) {
int a = 10;
int b = 0;

    int result = a / b;
    System.out.println("Result: " + result);
}

}

Solution for exception:

Here we cant divide number by zero. This is caught at runtime. so arithmetic exception will comes under unchecked exception. Below is the code with handled exception.

public class DivisionTest {

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

int a = 10;

int b = 0;

try {

       int result = a / b;

      System.out.println("Results: " + result);

   } 

  catch (ArithmeticException e) {

     System.out.println("Exception caught: Cannot divide by zero");

 }

}

}

2. Array Index Program :
public class ArrayTest {
public static void main(String[] args) {
int arr[] = {10, 20, 30, 40};

    System.out.println(arr[5]);
}

}

Solution:

Here the array index value is only 4. calling the 5th index will cause the ArrayIndexOutOfBoundsException. This comes under unchecked exception. This occurs at runtime only.

public class ArrayTest {

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

  int arr\[] = {10, 20, 30, 40};



 try {

        System.out.println(arr\[5]);

  } 

 catch (ArrayIndexOutOfBoundsException e) {

   System.out.println("Invalid array index");

     }

}
}

3. String Conversion Program :
public class NumberFormatTest {
public static void main(String[] args) {
String s = "ABC";

    int num = Integer.parseInt(s);
    System.out.println(num);
}

}

Solution:

Integer.parseInt(); -> This Method is used for converting string into int data type. It works only when the string contains numeric value. so here we will face NumberFormatException.

which occurs on runtime. So this is a unchecked exception.

public class NumberFormatTest {

public static void main(String[] args) {

String s = "ABC";

try { int num = Integer.parseInt(s);

System.out.println(num);}

catch(NumberFormatException e) {

   System.out.println("Unable to convert string to number");

}

}

NullPointer Program :
public class NullTest {
public static void main(String[] args) {
String name = null;
```
System.out.println(name.length());
```
}
}

Solution:

When the variable value is Null we cant use the length() method. we will get the NullPointerException. This occurs due to runtime. so it unchecked exception.

public class NullTest {

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

   String name = null;

   try { System.out.println(name.length());}

    catch(NullPointerException e) 

   {System.out.println("Name value should not be Null");

      }

}

}

5. File Reading Program :
public class FileTest {
public static void main(String[] args) throws Exception {
FileReader fr = new FileReader("test.txt");

    int data = fr.read();
    System.out.println(data);
}

}

Solution:

Here we request to read text from a file. Whether the file may exists or not. So, here we can expect the FileNotFoundException. This might be predicted and handled in compile time. This is checked exception.

public class FileTest {
    public static void main(String[] args) throws Exception {
       try{
         FileReader fr = new FileReader("test.txt");

        int data = fr.read();
        System.out.println(data);
}
catch(FileNotFoundException e)
{
System.out.println("File not Found in given path");
}
}
}

6. String Index Program :
public class StringIndexTest {
public static void main(String[] args) {
String str = "Java";

    System.out.println(str.charAt(10));
}

}

Solution:

Here the string length is only 4. But here we are calling the 10th index. So we will receive the StringIndexOutOfBoundsException. This is unchecked exception.

public class StringIndexTest {
    public static void main(String[] args) {
        String str = "Java";

       try
{ System.out.println(str.charAt(10));
}
catch(StringIndexOutOfBoundsException e)
{
System.out.println("Index out of range");
}
    }
}

7. Negative Array Size :
public class NegativeArrayTest {
public static void main(String[] args) {
int size = -5;

    int arr[] = new int[size];
}

}

Solution:

Array size cannot be in negative value.

NegativeArraySizeException.
It is an Unchecked Exception (Runtime Exception).

public class NegativeArrayTest {
    public static void main(String[] args) {
        int size = -5;

        try {
            int arr[] = new int[size];
        } 
        catch (NegativeArraySizeException e) {
            System.out.println("Exception caught: Array size cannot be negative");
        }
    }
}

8.TreeSet Programs :
public class Test
{
public static void main(String[] args) {
TreeSet set = new TreeSet();
set.add(10);
set.add(30);
set.add("hari");
System.out.println(set);
}
}

Solution:

TreeSet will give give the values in sorted order. While comparing the value we will receive the ClassCastException. This will occurs in runtime. so this belongs to unchecked exception.

import java.util.TreeSet;

public class Test {
    public static void main(String[] args) {
        TreeSet set = new TreeSet();

        try {
            set.add(10);
            set.add(30);
            set.add("hari");   // different data type
            System.out.println(set);
        } 
        catch (ClassCastException e) {
            System.out.println("Cannot add different data types in TreeSet");
        }
    }

9.TreeSet programs :
public class Test
{
public static void main(String[] args) {
TreeSet set = new TreeSet();
set.add(20);
set.add(40);
set.add(null);

}
}

Solution:

TreeSet stores elements in sorted order, so it compares elements.
When you add null, Java cannot compare it with other elements.

public class Test {
    public static void main(String[] args) {
        TreeSet set = new TreeSet();

        try {
            set.add(20);
            set.add(40);
            set.add(null);
        } 
        catch (NullPointerException e) {
            System.out.println("Exception caught: TreeSet does not allow null values");
        }

        System.out.println(set);
    }
}

Map Interface

Indumathy — Fri, 13 Mar 2026 13:39:57 +0000

Introduction
In Java, Mapping means storing data in key–value pairs using the Map interface in the Java Collection Framework.
A key is used to identify a value. When we provide the key, we can easily retrieve the corresponding value.

Example:
Key → Student ID
Value → Student Name

So, when we give the student ID, we can get the student name easily.
Map Interface in Java

In Java, mapping is implemented using the Map interface.

Important Rules
Key
Duplicate keys are not allowed

Value
Duplicate values are allowed

Example:.

Key, Value

101, Kumar

102, Yogesh

103, Hari

Null Values

Only one null key is allowed (in HashMap)
Multiple null values are allowed

Common Classes in Map Interface

The most commonly used classes are:

HashMap
LinkedHashMap
TreeMap****

HashMap in Java

HashMap is the most commonly used class in the Map interface.

Syntax

HashMap map = new HashMap<>();

Example:

import java.util.HashMap;

public class Sample {

public static void main(String[] args) {

    HashMap<Integer, String> map = new HashMap<>();

    map.put(101, "Kumar");
    map.put(102, "Yogesh");
    map.put(103, "Hari");

    System.out.println(map);
}

}
Output

{101=Kumar, 102=Yogesh, 103=Hari}

Important HashMap Methods

1. put() Method

Used to add key-value pairs.

map.put(101, "Kumar");
map.put(102, "Yogesh");
map.put(103, "Hari");

2. get() Method

Used to retrieve a value using the key.

Example:

map.put(101, "Kumar");
map.put(102, "Yogesh");
map.put(103, "Hari");
System.out.println(map.get(101));

Output

Kumar

3. remove() Method

Used to remove an element from the map.

Example:

map.put(101, "Kumar");
map.put(102, "Yogesh");
map.put(103, "Hari");
map.remove(101);
System.out.println(map);

Output
{102=Yogesh, 103=Hari}

You can also remove using key and value.

map.remove(101, "Kumar");
System.out.println(map);

4. containsKey() Method

Checks whether the key exists in the map.

Example:


map.put(101, "Kumar");
map.put(102, "Yogesh");
map.put(103, "Hari");
System.out.println(map.containsKey(103));

Output:
True

5. containsValue() Method

Checks whether the value exists in the map.
Example:

map.put(101, "Kumar");
map.put(102, "Yogesh");
map.put(103, "Hari");
System.out.println(map.containsValue("Hari"));

Output:

True

6. size() Method

Returns the number of elements in the map.
Example:

map.put(101, "Kumar");
map.put(102, "Yogesh");
map.put(103, "Hari");
System.out.println(map.size());

Output:
3

7. isEmpty() Method

Checks whether the map is empty or not.

Example:

map.put(101, "Kumar");
map.put(102, "Yogesh");
map.put(103, "Hari");
System.out.println(map.isEmpty());

Output:
False

8. clear() Method

Removes all elements from the map.

Example:

map.put(101, "Kumar");
map.put(102, "Yogesh");
map.put(103, "Hari");
map.clear();
System.out.println(map);

Output:
{}

Conclusion:

The Map Interface in Java is used to store data in key–value pairs. It allows quick retrieval of values using keys.
Among the different implementations:
HashMap → Fast and widely used
LinkedHashMap → Maintains insertion order
TreeMap → Stores keys in sorted order

ArrayList

Indumathy — Sat, 07 Mar 2026 15:25:32 +0000

ArrayList Class

ArrayList is one of the most commonly used classes in Java.
It implements the List interface.

Package: java.util

Syntax
ArrayList name = new ArrayList();

Features of ArrayList

Allows duplicate values
Maintains insertion order
Allows multiple null values
Dynamic size (it grows automatically)

Difference Between remove() and clear()
remove()
Removes a specific element from the list.
clear()
Removes all elements from the list.

Iterating Through List

We can use a for-each loop to iterate through elements.

for(String name : list){
System.out.println(name);
}

Let's See some common methods:
Lets create the student name list by ArrayList and make changes.

1.add()

Add Student Names Using ArrayList

import java.util.ArrayList;
import java.util.List;

public class Demo {

    public static void main(String[] args) {

        ArrayList<String> std = new ArrayList<String>();

        std.add("Hari");
        std.add("Indu");
        std.add("Kevin");

        System.out.println(std);

    }
}

Output

[Hari, Indu, Kevin]

2. add(index,"name")

Used to add name in specific place or index.

ArrayList<String> std = new ArrayList<String>();

        std.add("Hari");
        std.add("Indu");
        std.add("Kevin");
        std.add(0,"Arul");
        System.out.println(std);

Output:
[Arul, Hari, Indu, Kevin]

3.get(index)

Used to print the student name in given index.

ArrayList<String> std = new ArrayList<String>();

        std.add("Hari");
        std.add("Indu");
        std.add("Kevin");

        System.out.println(std.get(0));

output:
[Hari]

4.set(index,name)

Used to update or replace the student name in given index.

ArrayList<String> std = new ArrayList<String>();

        std.add("Hari");
        std.add("Indu");
        std.add("Kevin");
        std.set(0,"abc");
        System.out.println(std);

output:
[abc, Indu, Kevin]

5.remove(index)

Used to remove the name from specific index

ArrayList<String> std = new ArrayList<String>();

        std.add("Hari");
        std.add("Indu");
        std.add("Kevin");
        std.remove(0);
        System.out.println(std);

output:
[Indu, Kevin]

6.remove(value)

Used to remove particular student name.

ArrayList<String> std = new ArrayList<String>();

        std.add("Hari");
        std.add("Indu");
        std.add("Kevin");
        std.remove("Indu");
        System.out.println(std);

output:
[Hari, Kevin]

7.size()

Used to count the number of students

ArrayList<String> std = new ArrayList<String>();

        std.add("Hari");
        std.add("Indu");
        std.add("Kevin");

        System.out.println(std.size());

output:
[3]

8.contains(value)

Used to check if a student name is present in the list.

ArrayList<String> std = new ArrayList<String>();

        std.add("Hari");
        std.add("Indu");
        std.add("Kevin");

        System.out.println(std.contains("abc"));

output:
[false]

9. isEmpty()

Used to check whether the list is empty or not.

ArrayList<String> std = new ArrayList<String>();

System.out.println(std.isEmpty());

Output:
[True]

10. clear());

ArrayList<String> std = new ArrayList<String>();

std.add("Indu");
std.add("Arul");
std.clear();
System.out.pritnln(std);

Output:
[]

Collection

Indumathy — Sat, 07 Mar 2026 14:13:50 +0000

Java Collection Framework:

The Java Collection Framework is a predefined architecture that helps developers store and manipulate groups of objects efficiently.
It provides ready-made classes, interfaces, and methods to manage data easily.

What is a Framework?

A framework is a predefined structure that provides ready-made tools, libraries, and classes to help developers build applications faster and more efficiently.

Benefits of Framework

Reusable packages and classes
Reduces development time
Improves code organization

Java Collection Framework

The Collection Framework in Java is used to store and manipulate groups of objects as a single unit.
It is available in the java.util package:

Collection Interfaces Structure

The main interfaces in the Java Collection Framework are:

List Interface

The List interface is part of the java.util package.

Features of List

Allows duplicate values
Maintains insertion order
Allows index-based operations
We cannot create objects directly for List because it is an interface.

Common Methods
add()
get()
remove()
size()

Set Interface

The Set interface stores unique elements.

Features

Does not allow duplicate values
Does not maintain insertion order (in HashSet)
Does not support index-based operations

Implementations
HashSet
TreeSet
LinkedHashSet

Queue Interface

The Queue interface follows the FIFO principle.
FIFO = First In First Out
This means the first element inserted will be the first element removed.

Implementations:
PriorityQueue
LinkedList

Array

Indumathy — Fri, 06 Mar 2026 11:45:57 +0000

What is an Array?
An array is a collection of similar data types stored in a continuous memory location.
Arrays are used when we need to store multiple values in a single variable instead of creating many separate variables.
Example
Instead of writing:
int a = 10;
int b = 20;
int c = 30;
We can store them in one array:
int[] arr = {10,20,30};

Array Declaration in Java
Array declaration means creating a reference variable for the array.
Two ways to declare an array:

int[] arr;
or
int arr[];
Both are valid in Java.

**Array Creation
**After declaration, we need to allocate memory for the array.

arr = new int[5];

This creates an array that can store 5 integer values.

Declaration + Creation (Shortcut)
We can also do both together:

int[] arr = new int[5];

Array Initialization

Initialization means assigning values to the array elements.

Method 1: Using Index

arr[0] = 10;
arr[1] = 20;
arr[2] = 30;
arr[3] = 40;
arr[4] = 50;

Here, the numbers inside [ ] are called index values.
Array index always starts from 0.

Method 2: Shortcut Initialization

int[] arr = {10,20,30,40,50};

This is the easiest way to initialize an array.

Printing All Elements of an Array:

We can use a for loop to print all elements.

public class Main
{
public static void main(String[] args)
{
int[] arr = {10,20,30,40,50};

    for(int i = 0; i < arr.length; i++)
    {
        System.out.println(arr[i]);
    }
}

}

Output

10
20
30
40
50
arr.length returns the size of the array.

Accessing Required Index

We can access any specific element using its index number.

public class School
{
public static void main(String[] args)
{
int[] arr = {10,20,30,40,50};

    System.out.println(arr[3]);
}

}

Output

Explanation:

Index : 0 1 2 3 4
Value : 10 20 30 40 50
So arr[3] returns 40.

Array Index Out of Bounds Exception
If we try to access an index that does not exist, Java will throw an exception.

System.out.println(arr[10]);

ArrayIndexOutOfBoundsException
Because the array size is only 5, and index 10 does not exist.

Iteration in array

Iteration means repeating a block of code multiple times until the condition become false. In Array we can do iteration using for loop.

int[] marks = {10,20,30,40};
for (int i= 0; i<marks.length; i++)
{
System.out.println(marks[i]);
}

Output:
10
20
30
40

from the above value if we want only 3 values than we need to do changes in for loop.

for(int i =; i<marks.length-1; i++)

How to finde length of array

int[] marks = {10,20,30,40};
System.out.println(marks.lenghth);

length is predefined intance variable for array.

Reversing the values

int[] marks = {10,20,30,40};
for (int i= marks.length-1; i>=0; i--)
{
System.out.println(marks[i]);
}
Output:
40
30
20
10

String data type in array:

Example for printing first letter in each name.

String[] names= {"indu", "kavin", "nethra"};
for(int i =; i<marks.length-1; i++)
{
String a= names[i];
System.out.println(a.charAt(i)); // charAt is predefined method in String class
}
Output:
i
k
n

Example for changing first letter to capital for all values.

String[] names= {"indu", "kavin", "nethra"};
for(int i =; i<marks.length-1; i++)
{
String a= names[i];
Character b = a.charAt(i);
System.out.println(b.toUpperCase(b));
}

Output:
I
K
N

Scanner Class

Indumathy — Fri, 06 Mar 2026 11:15:40 +0000

Class in Java

Definition
The Scanner class is a predefined class in Java used to take input from the user.
It belongs to:
java.util package

Why Scanner?
It is used to read:
int
double
float
String
boolean
long
etc.

How to Use Scanner

Step 1: Import the package

import java.util.Scanner;

Step 2: Create Scanner Object

Scanner sc = new Scanner(System.in);

✔ System.in → Takes input from keyboard
✔ sc → Object name

Step 3: Take Input

int age = sc.nextInt();

String name = sc.nextLine();

double salary = sc.nextDouble();

Important Concept (Very Important 🔥)

If you write:

int age = sc.nextInt();
String name = sc.nextLine();

The nextLine() may get skipped because nextInt() does not consume the newline.

✔ Correct way:

int age = sc.nextInt();
sc.nextLine(); // consume leftover newline
String name = sc.nextLine();

Common Scanner Methods

nextInt()-Integer
nextDouble() - Decimal number
next() - Single word
nextLine() - Full sentence
nextBoolean() - true/false

Always Close Scanner
Java
Copy code
sc.close();

Scanner Class

Indumathy — Fri, 20 Feb 2026 13:53:05 +0000

Class in Java

Definition
The Scanner class is a predefined class in Java used to take input from the user.
It belongs to:
java.util package

Why Scanner?
It is used to read:
int
double
float
String
boolean
long
etc.

How to Use Scanner

Step 1: Import the package

import java.util.Scanner;

Step 2: Create Scanner Object

Scanner sc = new Scanner(System.in);

✔ System.in → Takes input from keyboard
✔ sc → Object name

Step 3: Take Input

int age = sc.nextInt();

String name = sc.nextLine();

double salary = sc.nextDouble();

Important Concept:

If you write:

int age = sc.nextInt();
String name = sc.nextLine();

The nextLine() may get skipped because nextInt() does not consume the newline.

Correct way:

int age = sc.nextInt();
sc.nextLine(); // consume leftover newline
String name = sc.nextLine();

Common Scanner Methods

nextInt()-Integer
nextDouble() - Decimal number
next() - Single word
nextLine() - Full sentence
nextBoolean() - true/false

Always Close Scanner

sc.close();

Example:
If we want to get the 5 subject marks from user and print the total we can use the scanner class and achieve this.
import java.util. Scanner;
public class TotalMarks {

    public static void main(String[] args) {

        Scanner sc = new Scanner(System.in);

        System.out.println("Enter Tamil mark:");
        int tamil = sc.nextInt();

        System.out.println("Enter English mark:");
        int english = sc.nextInt();

        System.out.println("Enter Maths mark:");
        int maths = sc.nextInt();

        System.out.println("Enter Science mark:");
        int science = sc.nextInt();

        System.out.println("Enter Social mark:");
        int social = sc.nextInt();
        sc.nextLine();

        System.out.println("Student name");

        String name = sc.nextLine();

        int total = tamil + english + maths + science + social;
        System.out.println("Total Marks" + total);
        System.out.println("Student name"+name);

        sc.close();   // Good practice
    }
}

Abstraction

Indumathy — Fri, 20 Feb 2026 13:37:01 +0000

Abstraction in Java
Definition:
Abstraction is the process of hiding implementation details and showing only essential functionality to the user.

We know what it does, but not how it does it.

Real-Time Example:
When using an ATM machine:
You press Withdraw
You get money
But you don’t know the internal banking process.
That is Abstraction.
How to Achieve Abstraction in Java?

Using Abstract Class
Using Interface (100% abstraction)

** Example Using Abstract Class**

✔ Abstract Class

abstract class Payment {

abstract void pay();   // abstract method

void message() {       // normal method
    System.out.println("Payment processing");
}

}

✔ Child Class

class UPI extends Payment {

void pay() {
    System.out.println("Paid using UPI");
}

public static void main(String[] args) {

    UPI u = new UPI();
    u.message();
    u.pay();
}

}

✔ Output:

Payment processing
Paid using UPI

Why Abstraction?

✔ Reduces complexity
✔ Improves security
✔ Increases maintainability
✔ Focus on "What" not "How"

*Important Points *

Abstract class can contain:

Abstract methods
Normal methods
Instance variables
Constructors

✅ We cannot create object of abstract class directly.
✅ Child class must implement abstract methods.

Inheritance

Indumathy — Thu, 12 Feb 2026 09:08:40 +0000

It is used for code reuse and to reduce the duplication.
Here the child object behaving as a parent Object.
By using "extends" keyword we can achieve inheritance.
When there is Is-A relationship between two class we can use inheritance.

Real time Scenario:

In a company employee is a common concept. Developer, Tester, HR, Admin are specific type of employee.
All the employee will commonly have their ID and salary detail.
Here we can use the ID, salary and other common data(variables) in all classes by inheritance method with the help of "extends" keyword.

Example:

package inheritance;

public class Employee {
int empid;
int salary;

public static void main(String[] args) {
    Employee hr1 = new Employee();
    hr1.work();


}

public void work()
{
System.out.println("Emloyee");

}

}

_**USING INHERITANCE FOR DEVELOPER***_*

package inheritance;

public class Developer extends Employee {

public static void main(String[] args) {
Developer dev1 = new Developer();
dev1.empid=1;
dev1.salary=1000;
dev1.work();

System.out.println(dev1.empid);
System.out.println(dev1.salary);

}

Scenario 2:

In a car showroom all the cars will have the common data like price, year,
version and owner detail. we can create variables in common Class (Vehicles) and later call the variables in another class for specific class (BMW).

Example:

package inheritance;

public class Vehicle {
int price;
int year;
double version;
String owner;

void showroom() {
    System.out.println("ABC Automobiles");
}

}

****USING INHERITANCE FOR BMW MODEL***

package inheritance;

public class BMW extends Vehicle
{
void brand()
{
System.out.println("BMW");
}
public static void main(String[] args) {
BMW customer1 = new BMW();
customer1.price=300000;
customer1.year=2026;
customer1.version=8.0;
customer1.owner="Indumathy";
customer1.showroom();
customer1.brand();

System.out.println("Price- "+customer1.price);  
System.out.println("Manufactured- "+customer1.year);
System.out.println("Version- "+customer1.version);
System.out.println("Owner- "+customer1.owner);
}

}

Output:

ABC Automobiles
BMW
Price- 300000
Manufactured- 2026
Version- 8.0
Owner- Indumathy

Contstructor

Indumathy — Tue, 10 Feb 2026 13:48:19 +0000

Constructor is a special method used to initialize an value for instance variable when the object created.

When we created and object, constructor will automatically run.
Constructor name will be the class name

Syntax:
Class Name
{
int id;
Name(int id) //constructor
}

Why Constructor?

It is used to Initialize the value immediately.
No chance for creating incomplete object.

Types of Constructor:

Default constructor

No parameter
Provided by java if we don't provide any constructor.

Parameterized constructor:

Has parameter.
Used to pass value while creating object.

Example:
Test(int a)
{
System.out.println(100);
}

Example for constructor:

Scenario: In the student register name and roll no must be entered initially.

package moduleFour;

public class College {
int rollno;
String name;

College(int rollno,String name)
{
    this.rollno = rollno;
    this.name = name;
}
public static void main(String[] args) {
    College student1 = new College(2001,"Kavin");
    College student2 = new College(2002,"Nethra");
    System.out.println(student1.rollno);
    System.out.println(student2.name);;
}

}

Output:
2002
Nethra

_Constructor Overloading: _

Constructor overloading is creating object in different ways with multiple constructor with different parameter.

(i.e) having more than one constructor in same class with different parameter

Why?

To create object in different ways.
To provide default or custom values for object.

Example for Constructor Overloading:

package moduleFour;

public class College2 {
int rollno;
String name;
int age;

College2(int rollno,String name,int age)
{
this.rollno = rollno;
this.name = name;
this.age = age;
}
College2(int rollno,String name)
{
this.rollno = rollno;
this.name = name;
}
public static void main(String[] args) {
College2 student1 = new College2(2001,"Kavin",18);
College2 student2 = new College2(2002,"Nethra");
System.out.println(student1.rollno); //2001
System.out.println(student1.age); //18
System.out.println(student2.name); // Nethra
}
}

Looping Statement

Indumathy — Fri, 06 Feb 2026 09:47:52 +0000

Looping statements are used when we want to repeat the block of code multiple times as long as a certain conditions remains true.
There are three main looping statements.

for loop
while loop
do while loop

for loop:

The for loop is ideal when the number of executions known in advance.
Syntax:

for(initialization; condition; Increment/decrement)

Example: For printing numbers form 1 ot 7

for(int i = 1; i<=7; i++)
{
System.out.println(i);
}

Output:
1
2
3
4
5
6
7

while lopp:

The while loop used when the number of execution is not fixed and depends on the condition.

Syntax:

initialization;
while(condition)
{
//code to be executed
increment/decrement;
}

Example:

int i = 1;
while(i<=3)
{
System.out.println(i);
i++;
}

Output:
1
2
3