DEV Community: Dinesh G

Comparable and Comparator

Dinesh G — Tue, 24 Feb 2026 08:33:06 +0000

Comparable Interface

Comparable Interface is meant for default natural Sorting order.
It is present in Java.lang package.
it is Contains Only one method Compare To().
Compare To() method is responsible to sort the elements.

You define the natural ordering for your objects by implementing the Comparable’s compareTo(T o) method in your custom objects. For example, if we want to compare the Person object based on the first name we’ll implement the Comparable interface .

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;

public class ComparatorExample {
  public static void main(String[] args) {
    ArrayList  al  = new ArrayList();
    al.add("jai");
    al.add("vijay");
    al.add("maddy");
    al.add("ajai");
    al.add("don");
    Collections.sort();
    System.out.println(al);
  }
}

Comparator Interface

Comparator Interface is meant for Customized Sorting Order.
It is present in Java.util.
It contains two method Compare() method and equals().
Compare()method is responsible to sort the elements.

If we want to define a total ordering on an object that has no natural ordering or if we want to override the natural ordering then we leverage the Comparator interface to do so. For example, if we want to override the natural ordering of Person objects and compare the Person object based on the age we’ll implement the Comparator interface

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;

public class ComparatorExample implements Comparator <String>{
  public static void main(String[] args) {
    ArrayList  al  = new ArrayList();
    al.add("jai");
    al.add("vijay");
    al.add("maddy");
    al.add("ajai");
    al.add("don");
    Collections.sort(al,new ComparatorExample());
    System.out.println(al);
  }

  @Override
  public int compare(String o2, String o1) {
    return o2.compareTo(o1);
  }
}

ArrayList and LinkedList

Dinesh G — Tue, 17 Feb 2026 12:49:33 +0000

ArrayList: The Dynamic Array

An ArrayList is like a dynamic array.

It stores elements by their index, so you can quickly jump to any element you want. It can hold all sorts of elements, even null, and it’s totally fine with duplicates.

Some operations in an ArrayList are super fast and take the same amount of time no matter how many elements you've got. These include set, get, iterator, ListIterator, isEmpty, and size.

Think of an ArrayList like a resizable array.

It stores elements in a contiguous block of memory (like seats in a theater). If you know the position of an element, you can instantly access it — just like finding your seat by number.

when:

You need fast random access
You rarely insert or remove elements in the middle
You deal with fixed or moderately changing lists

import java.util.ArrayList;

public class Main {
    public static void main(String[] args) {
        ArrayList<String> shoppingList = new ArrayList<>();

        // Adding items to the shopping list
        shoppingList.add("Balloons");
        shoppingList.add("Streamers");
        shoppingList.add("Cake");
        shoppingList.add("Ice Cream");
        shoppingList.add("Soda");

        System.out.println("Shopping list for the party:");
        System.out.println(shoppingList);

        // Accessing an item by index
        String cake = shoppingList.get(2);
        System.out.println("Gotta make sure we got the cake: " + cake);

        // Checking if the list is empty
        boolean isEmpty = shoppingList.isEmpty();
        System.out.println("Is the shopping list empty? " + isEmpty);

        // Checking the size of the list
        int size = shoppingList.size();
        System.out.println("Number of items on the list: " + size);

        // Finding the index of "Ice Cream"
        int iceCreamIndex = shoppingList.indexOf("Ice Cream");
        System.out.println("Ice Cream is at index: " + iceCreamIndex);

        // Removing an item (uh oh, someone decided no soda!)
        shoppingList.remove("Soda");
        System.out.println("Shopping list after removing Soda:");
        System.out.println(shoppingList);

        // Iterating through the list with a for-each loop
        System.out.println("Checking off the items:");
        for (String item : shoppingList) {
            System.out.println("Got " + item);
        }

        // Clearing the list after the party
        shoppingList.clear();
        System.out.println("Is the shopping list empty after the party? " + shoppingList.isEmpty());

        // Adding a new item post-party (we forgot to clean up!)
        shoppingList.add("Cleaning Supplies");
        System.out.println("Post-party shopping list:");
        System.out.println(shoppingList);
    }
}

LinkedList: The Chain Connection

Data structure used: Doubly linked list

The LinkedList is a dynamic data structure and part of the Java Collections Framework. It implements a doubly linked list, meaning each element (node) stores the actual data and references to both the previous and next nodes in the sequence.

A LinkedList, on the other hand, is like a chain of train cars — each car (called a node) holds data and a link to the next and previous cars.

when:

You frequently add or remove elements
You don’t need fast random access
You’re implementing queues, stacks, or iterative traversals

import java.util.LinkedList;

public class LinkedListt {
    public static void main(String[] args) {
        LinkedList<String> queue = new LinkedList<>();

        // People join the line
        queue.add("Alice");
        queue.add("Bob");
        queue.add("Charlie");
        queue.add("Diana");
        queue.add("Eve");

        System.out.println("The line for ice cream:");
        System.out.println(queue);

        // Peek at the first person in line without removing them
        String firstPerson = queue.peek();
        System.out.println("First person in line (peek): " + firstPerson);

        // Bob gets impatient and leaves
        queue.remove("Bob");
        System.out.println("Line after Bob leaves:");
        System.out.println(queue);

        // Serve the first person in line
        String servedPerson = queue.removeFirst();
        System.out.println(servedPerson + " got served ice cream!");

        // Peek again to see who's next
        String nextPerson = queue.peek();
        System.out.println("Next person in line (peek): " + nextPerson);

        // Serve the next person
        servedPerson = queue.removeFirst();
        System.out.println(servedPerson + " got served ice cream!");

        // Check the size of the line
        int size = queue.size();
        System.out.println("Number of people left in line: " + size);

        // Clear the line because the ice cream shop ran out of ice cream
        queue.clear();
        System.out.println("Is the line empty now? " + queue.isEmpty());

        // Adding a new line just for fun
        queue.add("Frank");
        System.out.println("Frank is now first in line:");
        System.out.println(queue);

        // Remove first and last (only Frank in this case)
        queue.removeFirst();
        System.out.println("Is the line empty after Frank is served? " + queue.isEmpty());
    }
}

Collections in Java

Dinesh G — Tue, 17 Feb 2026 12:02:27 +0000

Collections in Java

Collection is a group of objects treated as a single unit.

Java Collections can achieve all the operations that you perform on a data such as searching, sorting, insertion, manipulation, and deletion.

Java Collection means a single unit of objects.

Java Collection framework provides many interfaces (Set, List, Queue, Deque) and classes (ArrayList, Vector, LinkedList, PriorityQueue, HashSet, LinkedHashSet, TreeSet).

(JCF) is a unified architecture of interface and class that help store ,organize and manipulicate groups of objects efficiently .

What is a framework

A framework provides a ready-made structure of classes and interfaces for building software applications efficiently.

It simplifies adding new features by offering reusable components that perform similar tasks, eliminating the need to create a framework from scratch for each new project.

This approach enhances object-oriented design, making development quicker, more consistent, and reliable.

It provides readymade architecture.
It represents a set of classes and interfaces.
It is optional.

Collection Framework

Interface
Implemention entations
Algorithms
(c++ Standard Templates library (STL))

Common Interface

List => Ordered ,Allow Duplicates, Maintain Insertion order.

Set => No Duplicate ,No insertion Order

Map => Stores Key value pairs (not part of collection interface but in framework).

Why

Readymade data Structure
Dynamic Size
Standardized API
Built in Algorithms
Flexible and Efficient

Interface in Java

Dinesh G — Mon, 09 Feb 2026 14:34:21 +0000

Interface in Java

An interface in the Java programming language is defined as an abstract type used to specify the behavior of a class. It is a blueprint of a behavior and contains static constants and abstract methods.

Syntax for Java Interfaces

interface {
    // declare constant fields
    // declare methods that are abstract 
    // by default.   
}

To declare an interface, use the interface keyword.

It is used to provide total abstraction. That means all the methods in an interface are declared with an empty body and are public, and all fields are public, static, and final by default. A class that implements an interface must implement all the methods declared in the interface. To implement the interface, use the implements keyword.

Uses of Interfaces in Java

It is used to achieve total abstraction.
Since Java does not support multiple inheritances in the case of a class, by using an interface, it can achieve multiple inheritances.
Any class can extend only one class but can implement multiple interfaces.
It is also used to achieve loose coupling.
Interfaces are used to implement abstraction.

When to Use Class and Interface?

Use a Class when:

Use a class when you need to represent a real-world entity with attributes (fields) and behaviors (methods).
Use a class when you need to create objects that hold state and perform actions
Classes are used for defining templates for objects with specific functionality and properties.

Use an Interface when:

Use an interface when you need to define a contract for behavior that multiple classes can implement.
Interface is ideal for achieving abstraction and multiple inheritance.
Implementation: To implement an interface, we use the keyword implements

Exception Handling in Java

Dinesh G — Mon, 09 Feb 2026 14:17:51 +0000

Introduction

Java exceptions are events that disrupt the normal flow of a program during runtime.

Java exceptions are events that disrupt the normal flow of a program during runtime. They are objects representing errors or unusual conditions that the program should handle to prevent crashing or unexpected behaviour.

When:

You should use exception handling to manage conditions that are outside the normal ,expected flow of a program.

Why:

Exception handling is crucial for writing reliable and robust applications

Preverts abnormal program termination
Provides meaningful error message
Ensure resources cleanup
Promotes code robustness

Types of Java Exceptions

1.Checked Exceptions

These are exceptions that are checked at compile time

The program must handle these exceptions using a try-catch block or declare them using the throws keyword.

Examples: IOException, SQLException, FileNotFoundException.

2.Unchecked Exceptions

These occur during runtime and are not checked at compile time.

They usually result from programming errors, such as logic mistakes or improper use of APIs.

Examples: NullPointerException, ArrayIndexOutOfBoundsException, ArithmeticException.

3.Errors

Represent serious problems that applications should not try to catch.

Examples: OutOfMemoryError, StackOverflowError.

Exception Handling in Java

try: Code that might throw an exception is enclosed in a try block.

catch: Handles specific exceptions thrown by the try block.

finally: Block that is always executed after try and catch, regardless of whether an exception occurred.

throw: Used to explicitly throw an exception.

throws: Declares exceptions that a method might throw.

Syntax Example

import java.io.*;

public class ExceptionExample {
    public static void main(String[] args) {
        try {
            // Code that may throw an exception
            FileInputStream file = new FileInputStream("test.txt");
        } catch (FileNotFoundException e) {
            // Handling the exception
            System.out.println("File not found: " + e.getMessage());
        } finally {
            // Always executed
            System.out.println("Execution completed.");
        }
    }
}

Commonly Used Exception Classes

IOException: Input-output operations failure.
SQLException: Database access errors.
ClassNotFoundException: Class not found during runtime.
ArithmeticException: Invalid arithmetic operations (e.g., division by zero).
NullPointerException: Attempt to use an object reference that is null.
IllegalArgumentException: Method has been passed an inappropriate argument.

Custom Exceptions

You can create custom exceptions by extending the Exception or RuntimeException class.

class MyCustomException extends Exception {
    public MyCustomException(String message) {
        super(message);
    }
}

public class CustomExceptionExample {
    public static void main(String[] args) {
        try {
            throw new MyCustomException("Custom error occurred");
        } catch (MyCustomException e) {
            System.out.println(e.getMessage());
        }
    }
}

Different Types of Exceptions

In Java, there are different kinds of problems, or exceptions. For example:

`ArithmeticException`: When you try to do math that doesn’t make sense, like dividing by zero.
`NullPointerException`: When you try to use something that doesn’t exist yet (like trying to open a treasure chest that isn’t there).
`ArrayIndexOutOfBoundsException`: When you try to reach into an array for something that's beyond its limits, like asking for the 11th cookie in a jar that only has 10.

Cleaning Up and Making Custom Exceptions

The finally Block

Imagine you’re playing a game and you find treasure, but whether you succeed or not, you always want to close the treasure chest when you're done. In Java, the finally block is like making sure the treasure chest is always closed, no matter what happens.

What is the finally Block?

The finally block is a piece of code that always runs, whether an exception happens or not. It’s used to clean up, like closing a file, stopping a timer, or putting away the treasure chest.

Let’s See an Example:

public class FinallyExample {
    public static void main(String[] args) {
        try {
            int result = 10 / 0; // This will cause an exception.
        } catch (ArithmeticException e) {
            System.out.println("Oops! You can’t divide by zero.");
        } finally {
            System.out.println("This will always run, no matter what.");
        }
    }
}

Here’s what happens:

The try block tries to do something risky.
The catch block catches the problem if it happens.
The finally block always runs, even if there’s no problem.

Exception Handling in Java

Dinesh G — Mon, 09 Feb 2026 14:12:43 +0000

Introduction

Java exceptions are events that disrupt the normal flow of a program during runtime.

When:

You should use exception handling to manage conditions that are outside the normal ,expected flow of a program.

Why:

Exception handling is crucial for writing reliable and robust applications

Preverts abnormal program termination
Provides meaningful error message
Ensure resources cleanup
Promotes code robustness

Types of Java Exceptions

1.Checked Exceptions

These are exceptions that are checked at compile time

The program must handle these exceptions using a try-catch block or declare them using the throws keyword.

Examples: IOException, SQLException, FileNotFoundException.

2.Unchecked Exceptions

These occur during runtime and are not checked at compile time.

They usually result from programming errors, such as logic mistakes or improper use of APIs.

Examples: NullPointerException, ArrayIndexOutOfBoundsException, ArithmeticException.

3.Errors

Represent serious problems that applications should not try to catch.

Examples: OutOfMemoryError, StackOverflowError.

Exception Handling in Java

try: Code that might throw an exception is enclosed in a try block.

catch: Handles specific exceptions thrown by the try block.

finally: Block that is always executed after try and catch, regardless of whether an exception occurred.

throw: Used to explicitly throw an exception.

throws: Declares exceptions that a method might throw.

Syntax Example

import java.io.*;

public class ExceptionExample {
    public static void main(String[] args) {
        try {
            // Code that may throw an exception
            FileInputStream file = new FileInputStream("test.txt");
        } catch (FileNotFoundException e) {
            // Handling the exception
            System.out.println("File not found: " + e.getMessage());
        } finally {
            // Always executed
            System.out.println("Execution completed.");
        }
    }
}

Commonly Used Exception Classes

IOException: Input-output operations failure.
SQLException: Database access errors.
ClassNotFoundException: Class not found during runtime.
ArithmeticException: Invalid arithmetic operations (e.g., division by zero).
NullPointerException: Attempt to use an object reference that is null.
IllegalArgumentException: Method has been passed an inappropriate argument.

Custom Exceptions

You can create custom exceptions by extending the Exception or RuntimeException class.

class MyCustomException extends Exception {
    public MyCustomException(String message) {
        super(message);
    }
}

public class CustomExceptionExample {
    public static void main(String[] args) {
        try {
            throw new MyCustomException("Custom error occurred");
        } catch (MyCustomException e) {
            System.out.println(e.getMessage());
        }
    }
}

Different Types of Exceptions

In Java, there are different kinds of problems, or exceptions. For example:

`ArithmeticException`: When you try to do math that doesn’t make sense, like dividing by zero.
`NullPointerException`: When you try to use something that doesn’t exist yet (like trying to open a treasure chest that isn’t there).
`ArrayIndexOutOfBoundsException`: When you try to reach into an array for something that's beyond its limits, like asking for the 11th cookie in a jar that only has 10.

Cleaning Up and Making Custom Exceptions

The finally Block

What is the finally Block?

The finally block is a piece of code that always runs, whether an exception happens or not. It’s used to clean up, like closing a file, stopping a timer, or putting away the treasure chest.

Let’s See an Example:

public class FinallyExample {
    public static void main(String[] args) {
        try {
            int result = 10 / 0; // This will cause an exception.
        } catch (ArithmeticException e) {
            System.out.println("Oops! You can’t divide by zero.");
        } finally {
            System.out.println("This will always run, no matter what.");
        }
    }
}

Here’s what happens:

The try block tries to do something risky.
The catch block catches the problem if it happens.
The finally block always runs, even if there’s no problem.

Types of Inheritances

Dinesh G — Mon, 24 Nov 2025 07:05:45 +0000

Types Of Inheritance

Single Level Inheritance
Multi Level Inheritance
Hierarchical Inheritance
Multiple Inheritance
Hybrid Inheritance

=> Java does not support multiple or hybrid inheritance through classes because it can lead to the diamond problem, resulting in ambiguity.

Single Level Inheritance

 Multilevel inheritance is a type of inheritance where one child class inherits the properties and behaviors of one parent class. It means there is only one parent and one child class.

Syntax:

class parent_class_name {
    void eat() { }
}

class child_class_name extends parent_class_name {
    void bark() { }
}

Multi level Inheritance

Multilevel inheritance is a type of inheritance where a class inherits from a child class which is already inherited from another class. It means there is a chain of inheritance, one parent, one  child, and one grandchild class.

Syntax:

class parent_class_name {

}

class child_class_name extends parent_class_name {

}

class grand_child_class_name extends child_class_name {

}

Hierarchical inheritance

Hierarchical inheritance is a type of inheritance where a single parent class is inherited by multiple child classes. In this structure, all child classes share the common properties and behaviors of the parent class, but they can also define their unique features.

Syntax:

class parent_class_name {

}

class child_class_name_1 extends parent_class_name {

}

class child_class_name_2 extends parent_class_name {

}

Inheritances in Java

Dinesh G — Mon, 24 Nov 2025 06:22:09 +0000

What is inheritances ?

An object of one class acting as an object of another class.

Inheritance in Java is a mechanism in which one object acquires all the properties and behaviors of a parent object. It is an important part of OOPs (Object Oriented Programming system.

[ Extends keyword -> child to parent ]

=> is a Relationship
=> has a Relationship

Subclass

The class that extends the features of another class is known as child class, subclass or derived class.

Superclass

The class whose properties and functionalities are used (inherited) by another class is known as parent class, superclass or Base class.

Advantages of Inheritance

Inheritance enables overriding, allowing the subclass to provide a meaningful implementation of a superclass method.
It promotes reusability by allowing the subclass to use the methods and fields defined in the parent class.
When changes are needed, updating the code in the superclass automatically reflects across all subclasses, simplifying maintenance.
Inheritance helps avoid code duplication by placing common logic in the superclass and sharing it across multiple classes.

Syntax:

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

class Child extends Parent {
    void show() {
        System.out.println(" child class.");
    }
}

Package in Java

Dinesh G — Sat, 22 Nov 2025 18:13:44 +0000

What is Package in java

A package is a namespace that organizes a set of related classes and interfaces.

Conceptually you can think of packages as being similar to different folders on your computer.

You might keep HTML pages in one folder, images in another, and scripts or applications in yet another.

Because software written in the Java programming language can be composed of hundreds or thousands of individual classes, it makes sense to keep things organized by placing related classes and interfaces into packages.

Why use?

Organization: Keeps related classes together

Avoid name conflict: if two classes with same name can exist in different packages.

Access Control: You can set visibility (like public, protected) using package.

Reusability: Easier to use classes in other projects.

Types of Packages in Java:

Built-in Packages:

These are predefined collections of classes and interfaces provided by Java to perform common tasks.

** Examples include**:

java.util
java.io
java.lang

User-defined Packages:

These are packages Created by developers to group related classes and interfaces Code, helping to Organize and avoid name Conflicts.

Developers Create Custom packages to Structure their applications in a logical manner.

Eg:

package mypackage;

public class Message {
    public void showMessage() {
        System.out.println("Hello from mypackage!");
    }
}

Constructor overloading in java

Dinesh G — Sat, 15 Nov 2025 10:36:32 +0000

What is Constructor Overloading?

Constructor overloading in Java means having multiple constructors in the same class, each with a different parameter list.
The constructors are differentiated by the number and types of their parameters.
This allows you to create objects with varying initial states based on what data is available when the object is instantiated.

Why Use Constructor Overloading?

Constructor overloading is useful for several reasons:

Flexibility: It provides multiple ways to create objects with different initial values.
Convenience: Users of your class can choose which constructor to call based on the information they have.
Code Reusability: It allows for a default setup while still enabling customization.

Example of Constructor Overloading

Let’s consider a simple example of an Employee class to see how constructor overloading works

public class Employee {
    private String name;
    private int id;
    private double salary;

    // Constructor 1: No parameters
    public Employee() {
        this.name = "Unknown";
        this.id = 0;
        this.salary = 0.0;
    }

    // Constructor 2: One parameter (name)
    public Employee(String name) {
        this.name = name;
        this.id = 0;
        this.salary = 0.0;
    }

    // Constructor 3: Two parameters (name and id)
    public Employee(String name, int id) {
        this.name = name;
        this.id = id;
        this.salary = 0.0;
    }

    // Constructor 4: Three parameters (name, id, and salary)
    public Employee(String name, int id, double salary) {
        this.name = name;
        this.id = id;
        this.salary = salary;
    }

    public void displayInfo() {
        System.out.println("Name: " + name + ", ID: " + id + ", Salary: " + salary);
    }
}

How Does It Work?

In the Employee class above:

Constructor 1 is a no-argument constructor that sets default values for the name, id, and salary.
Constructor 2 allows you to set the name, with id and salary defaulting to 0.
Constructor 3 lets you set both name and id, while salary still defaults to 0.
Constructor 4 gives you the flexibility to set all three fields: name, id, and salary.

Methods in Java

Dinesh G — Sat, 15 Nov 2025 10:21:29 +0000

What is methods in java

Method :

A method is a block of code that performs a specific task and declared within the class. Methods are fundamental to object-oriented programming in Java, as they encapsulate the behavior of objects.
Set of instructions for achieving a specific-tasks - with a name (or) with or without arguments (or) with or without return datatype.
If we do not return any value, we should mention void before method name.
Modularity
Code Reusability

employee1.enquiry(); employee1.enquiry(1234); }

private void enquiry(int accNo) {
    System.out.println("Balance enquiry");

}

private void enquiry() {
    System.out.println("General enquiry");

}

Same method name with different number of arguments is called Method overloading.

employee1.enquiry(15.3f); private void enquiry(float gold) { System.out.println("Gold rate please"); }

Same method name with different type of arguments is also known as Method overloading.

Another name called Compile time polymorphism.

Types of Methods:

User-Defined Methods: Created by the programmer to perform custom tasks.
Standard Library Methods: Predefined methods provided by Java's API (e.g., System.out.println()).

Why use methods?

Code Reusability: Define code once and call it multiple times.
Modularity: Break down complex programs into smaller, manageable units.
Readability and Maintainability: Improve code structure and make it easier to understand and debug

Variable and Objects in Java

Dinesh G — Thu, 13 Nov 2025 17:09:22 +0000

Variable and Objects

What is Variable in Java

In Java Variable is a name given to a memory location that stores data. It acts as Contains to hold Values that Canused and changed during program execution Variable make it store,retrieve and manipulate information while running program, Each Variable has data type that defined what kind Value it Can store Such as int,float, String.

Variables are containers for storing data values. It acts like a name given to a value stored in memory.

This can be classified into two types : local and global variable.

Ex:

int age = 21;

Here int - data type
age - variable name
21 - value assigned to a variable

Local variable:

Created when a block is entered into the storage, and then it calls and destroys the block just after exiting from the function (TBH)

A local variable is declared inside a function or block and can only be accessed from within that function or block.

Eg:

public class Home{
public static void main(String[] args){
String name = "Flower";
int age = 21;
System.out.println(name);
System.out.println(age);

Output:

Flower
21

Global variable:

Key Concepts:
Variable Types: Variables are categorized into global (Field) and local.

Global variables can be static or non static.

Global Variable Definition: A global variable is declared outside of any function or accessible block and can be accessed from anywhere in the code.

Risks of Global Variables:

They can be accidentally overwritten.
They persist throughout the program, consuming memory.
In large codebases, they can cause naming conflicts.

It is declared outside the methods or blocks and can be accessed anywhere in the program. This can be further divided into two types : static and non-static.

Static variable: This variable is declared using static keyword inside a class. It is shared by all objects in class and has 1 memory copy.

Eg:

public class House{
public static String name = "Dinesh";
static int Doorno = 30;
public static void main(String[] args){
System.out.println(name);
System.out.println(Doorno);
}
}

Output:

Dinesh
30

Non-static: This variable is declared to a specific object information. It has multiple memory copy based on object.

Ex:

public class House{
String name = "Flower";
int age = 21;
public static void main(String args[]){
System.out.println(name);
System.out.println(age);
}
}

Objects

What is the Object Class?

An object in Java is a basic unit of Object-Oriented Programming and represents real-life entities. Objects are the instances of a class that are created to use the attributes and methods of a class. A typical Java program creates many objects, which as you know, interact by invoking methods.

*An object consists of *:

State : It is represented by attributes of an object. It also reflects the properties of an object.

Eg: what the objects have, Student have a first name, last name, age, etc.
Behavior : It is represented by the methods of an object. It also reflects the response of an object with other objects.

Eg: what the objects do, Student attend a course "Java for beginners".
Identity : It gives a unique name to an object and enables one object to interact with other objects.

Eg: what makes them unique, Student have Student-ID-number, or an email which is unique.

State
State is basically of two types:

Statically Typed Programming Language
Dynamically Typed Programming Language

Statically Typed Programming Language:

In statically typed programming languages, type checking occurs at compile time. At compile time, source code in a specific programming language is converted to a machine-readable format. This means that before source code is compiled, the type associated with each and every single variable must be known. Some common examples of programming languages that belong to this category are Java, Haskell, C, C++, C#, Scala, Kotlin, Fortran, Go, Pascal, and Swift.

Dynamically Typed Programming Language
In dynamically typed languages, type checking takes place at runtime or execution time. This means that variables are checked against types only when the program is executing. Some examples of programming languages that belong to this category are Python, JavaScript, Lisp, PHP, Ruby, Perl, Lua, and Tcl.