DEV Community: PRIYA K

Why Abstract in Java ?

PRIYA K — Mon, 22 Jun 2026 17:57:49 +0000

read gfg,w3schools,tutorialpoint,programmiz

Abstraction is a process of hiding the implementation details from the user, only the functionality will be provided to the use ,showing only essential features. In other words, the user will have the information on what the object does instead of how it does it. In Java programming, abstraction is achieved using Abstract classes and interfaces.It focuses on what an object does rather than how it does it.

It hides the complex details and shows only essential features. Abstract classes may have methods without implementation and must be implemented by subclasses. By abstracting functionality, changes in the implementation do not affect the code that depends on the abstraction.

Java provides two ways to implement abstraction, which are listed below:

Abstract Classes (Partial Abstraction)
Interface (provides abstraction for behavior, may contain default or static methods)

Example:

abstract class Animal {
    abstract void sound();   // abstract method

    void sleep() {           // concrete method
        System.out.println("Sleeping...");
    }
}

class Dog extends Animal {
    void sound() {
        System.out.println("Barking");
    }
}

Explanation:
Animal is an abstract class → cannot be instantiated.
sound() is abstract → must be implemented by Dog.
sleep() is shared by all animals.
Key Points:
You cannot create objects of an abstract class.
It is mainly used for inheritance and design structure.
Helps in writing clean, maintainable, and scalable code.

Why we use abstract in Java:
To define a common blueprint
An abstract class provides a base structure for other classes.
It ensures that all subclasses follow the same design.
To enforce method implementation
Abstract methods (methods without a body) must be implemented by subclasses.
This guarantees that certain behaviors are defined in child classes.
To achieve partial abstraction

Advantages of Abstraction

Abstraction makes complex systems easier to understand by hiding the implementation details.
Abstraction keeps different part of the system separated.
Abstraction maintains code more efficiently.
Abstraction increases the security by only showing the necessary details to the user.

Disadvantages of Abstraction
It can add unnecessary complexity if overused.
May reduce flexibility in implementation.
Makes debugging and understanding the system harder for unfamiliar users.
Overuse of abstraction may make code harder to follow, though performance impact is usually negligible.

Common Mistakes to Avoid

Not Implementing Abstract Methods: Always make sure that the abstract methods are implemented in the concrete subclass.
Overusing Abstraction: Avoid making everything abstract when it’s not required. Use abstraction only when it enhances the design.
Inconsistent Method Signatures in Subclasses: When you override abstract methods, please make sure the method signature matches exactly, any mistake can cause errors.

An abstract class can have both:
Abstract methods (no body)
Concrete methods (with body)
To avoid code duplication
Common code can be written once in the abstract class and reused by subclasses.

Java Abstract Classes

A Java class which contains the abstract keyword in its declaration is known as abstract class.
Java abstract classes may or may not contain abstract methods, i.e., methods without body ( public void get(); )
But, if a class has at least one abstract method, then the class must be declared abstract.
If a class is declared abstract, it cannot be instantiated(we cannot create objects of abstract classes).
To use an abstract class, you have to inherit it from another class, provide implementations to the abstract methods in it.
If you inherit an abstract class, you have to provide implementations to all the abstract methods in it.

An abstract class can have both the regular methods and abstract methods.

abstract class Language {

  // abstract method
  abstract void method1();

  // regular method
  void method2() {
    System.out.println("This is regular method");
  }
}

Example: Java Abstract Class
To create an abstract class in Java, just use the abstract keyword before the class keyword, in the class declaration.

/* File name : Employee.java */
public abstract class Employee {
   private String name;
   private String address;
   private int number;

   public Employee(String name, String address, int number) {
      System.out.println("Constructing an Employee");
      this.name = name;
      this.address = address;
      this.number = number;
   }

   public double computePay() {
     System.out.println("Inside Employee computePay");
     return 0.0;
   }

   public void mailCheck() {
      System.out.println("Mailing a check to " + this.name + " " + this.address);
   }

   public String toString() {
      return name + " " + address + " " + number;
   }

   public String getName() {
      return name;
   }

   public String getAddress() {
      return address;
   }

   public void setAddress(String newAddress) {
      address = newAddress;
   }

   public int getNumber() {
      return number;
   }
}

Explanation:except abstract methods the Employee class is same as normal class in Java. The class is now abstract, but it still has three fields, seven methods, and one constructor.

Inheriting the Java Abstract Class

We can inherit the properties of Employee class just like concrete class .

/* File name : Salary.java */
public class Salary extends Employee {
   private double salary;   // Annual salary

   public Salary(String name, String address, int number, double salary) {
      super(name, address, number);
      setSalary(salary);
   }

   public void mailCheck() {
      System.out.println("Within mailCheck of Salary class ");
      System.out.println("Mailing check to " + getName() + " with salary " + salary);
   }

   public double getSalary() {
      return salary;
   }

   public void setSalary(double newSalary) {
      if(newSalary >= 0.0) {
         salary = newSalary;
      }
   }

   public double computePay() {
      System.out.println("Computing salary pay for " + getName());
      return salary/52;
   }
}

Here, you cannot instantiate the Employee class, but you can instantiate the Salary Class, and using this instance you can access all the three fields and seven methods of Employee class.

/* File name : AbstractDemo.java */
public class AbstractDemo {

   public static void main(String [] args) {
      Salary s = new Salary("Mohd Mohtashim", "Ambehta, UP", 3, 3600.00);
      Employee e = new Salary("John Adams", "Boston, MA", 2, 2400.00);
      System.out.println("Call mailCheck using Salary reference --");
      s.mailCheck();
      System.out.println("\n Call mailCheck using Employee reference--");
      e.mailCheck();
   }
}
abstract class Employee {
   private String name;
   private String address;
   private int number;

   public Employee(String name, String address, int number) {
      System.out.println("Constructing an Employee");
      this.name = name;
      this.address = address;
      this.number = number;
   }

   public double computePay() {
     System.out.println("Inside Employee computePay");
     return 0.0;
   }

   public void mailCheck() {
      System.out.println("Mailing a check to " + this.name + " " + this.address);
   }

   public String toString() {
      return name + " " + address + " " + number;
   }

   public String getName() {
      return name;
   }

   public String getAddress() {
      return address;
   }

   public void setAddress(String newAddress) {
      address = newAddress;
   }

   public int getNumber() {
      return number;
   }
}
class Salary extends Employee {
   private double salary;   // Annual salary

   public Salary(String name, String address, int number, double salary) {
      super(name, address, number);
      setSalary(salary);
   }

   public void mailCheck() {
      System.out.println("Within mailCheck of Salary class ");
      System.out.println("Mailing check to " + getName() + " with salary " + salary);
   }

   public double getSalary() {
      return salary;
   }

   public void setSalary(double newSalary) {
      if(newSalary >= 0.0) {
         salary = newSalary;
      }
   }

   public double computePay() {
      System.out.println("Computing salary pay for " + getName());
      return salary/52;
   }
}

Output

Constructing an Employee
Constructing an Employee
Call mailCheck using Salary reference --
Within mailCheck of Salary class
Mailing check to Mohd Mohtashim with salary 3600.0

Call mailCheck using Employee reference--
Within mailCheck of Salary class
Mailing check to John Adams with salary 2400.0

Why And When To Use Abstract Classes and Methods?
To achieve security - hide certain details and only show the important details of an object.
Abstraction can also be achieved with Interfaces

Abstract Keyword
The abstract keyword is a non-access modifier, used for classes and methods:

Abstract class: is a restricted class that cannot be used to create objects (to access it, it must be inherited from another class).

Abstract method: can only be used in an abstract class, and it does not have a body. The body is provided by the subclass (inherited from).

An abstract method belongs to an abstract class, and it does not have a body. The body is provided by the subclass
An abstract class can have both abstract and regular methods.

Java Abstract Methods
a class to contain a particular method but you want the actual implementation of that method to be determined by child classes, you can declare the method in the parent class as an abstract.

abstract keyword is used to declare the method as abstract.
You have to place the abstract keyword before the method name in the method declaration.
An abstract method contains a method signature, but no method body.
Instead of curly braces, an abstract method will have a semi colon (;) at the end.

A method that doesn't have its body is known as an abstract method.

abstract void display();

Here, display() is an abstract method. The body of display() is replaced by ;.

If a class contains an abstract method, then the class should be declared abstract. Otherwise, it will generate an error. For example,

// error
// class should be abstract
class Language {

  // abstract method
  abstract void method1();
}

Example 1: Implementing Abstract Method in Java

public abstract class Employee {
   private String name;
   private String address;
   private int number;

   public abstract double computePay();
   // Remainder of class definition
}

Declaring a method as abstract has two consequences −

The class containing it must be declared as abstract.
Any class inheriting the current class must either override the abstract method or declare itself as abstract.

Note − Eventually, a descendant class has to implement the abstract method; otherwise, you would have a hierarchy of abstract classes that cannot be instantiated.

Suppose Salary class inherits the Employee class, then it should implement the computePay() method as shown below −

/* File name : Salary.java */
public class Salary extends Employee {
   private double salary;   // Annual salary

   public double computePay() {
      System.out.println("Computing salary pay for " + getName());
      return salary/52;
   }
   // Remainder of class definition
}

Example 2: Implementing Abstract Method in Java

/* File name : AbstractDemo.java */
public class AbstractDemo {
   public static void main(String [] args) {
      Salary s = new Salary("Mohd Mohtashim", "Ambehta, UP", 3, 3600.00);
      System.out.println("salary: " + s.computePay());
   }
}
abstract class Employee {
   private String name;
   private String address;
   private int number;

   public Employee(String name, String address, int number) {
      System.out.println("Constructing an Employee");
      this.name = name;
      this.address = address;
      this.number = number;
   }

   public abstract double computePay();
      // Remainder of class definition

   public String getName() {
      return name;
   }

   public void setName(String name) {
      this.name = name;
   }

   public String getAddress() {
      return address;
   }

   public void setAddress(String address) {
      this.address = address;
   }

   public int getNumber() {
      return number;
   }

   public void setNumber(int number) {
      this.number = number;
   }
}
class Salary extends Employee {
   private double salary;   // Annual salary

   public Salary(String name, String address, int number, double salary) {
      super(name, address, number);
      this.salary = salary;
   }

   public double computePay() {
      System.out.println("Computing salary pay for " + getName());
      return salary/52;
   }
   // Remainder of class definition
}

Output

Constructing an Employee
Computing salary pay for Mohd Mohtashim
salary: 69.23076923076923

**
Example: Java Abstract Class and Method**

Though abstract classes cannot be instantiated, we can create subclasses from it. We can then access members of the abstract class using the object of the subclass. For example,

abstract class Language {

  // method of abstract class
  public void display() {
    System.out.println("This is Java Programming");
  }
}

class Main extends Language {

  public static void main(String[] args) {

    // create an object of Main
    Main obj = new Main();

    // access method of abstract class
    // using object of Main class
    obj.display();
  }
}

Output
This is Java programming

we have created an abstract class named Language. The class contains a regular method display().

We have created the Main class that inherits the abstract class. Notice the statement,


obj.display();

Here, obj is the object of the child class Main. We are calling the method of the abstract class using the object obj.
Implementing Abstract Methods

If the abstract class includes any abstract method, then all the child classes inherited from the abstract superclass must provide the implementation of the abstract method. For example,

abstract class Animal {
  abstract void makeSound();

  public void eat() {
    System.out.println("I can eat.");
  }
}

class Dog extends Animal {

  // provide implementation of abstract method
  public void makeSound() {
    System.out.println("Bark bark");
  }
}

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

    // create an object of Dog class
    Dog d1 = new Dog();

    d1.makeSound();
    d1.eat();
  }
}

Output

Bark bark
I can eat.

we have created an abstract class Animal. The class contains an abstract method makeSound() and a non-abstract method eat().

We have inherited a subclass Dog from the superclass Animal. Here, the subclass Dog provides the implementation for the abstract method makeSound().

We then used the object d1 of the Dog class to call methods makeSound() and eat().

Note: If the Dog class doesn't provide the implementation of the abstract method makeSound(), Dog should also be declared as abstract. This is because the subclass Dog inherits makeSound() from Animal.

Accesses Constructor of Abstract Classes

An abstract class can have constructors like the regular class. And, we can access the constructor of an abstract class from the subclass using the super keyword. For example,

abstract class Animal {
   Animal() {
      ….
   }
}

class Dog extends Animal {
   Dog() {
      super();
      ...
   }
}

Here, we have used the super() inside the constructor of Dog to access the constructor of the Animal.

Note that the super should always be the first statement of the subclass constructor.

This allows us to manage complexity by omitting or hiding details with a simpler, higher-level idea.

A practical example of abstraction can be motorbike brakes. We know what brake does. When we apply the brake, the motorbike will stop. However, the working of the brake is kept hidden from us.

The major advantage of hiding the working of the brake is that now the manufacturer can implement brake differently for different motorbikes, however, what brake does will be the same.

Example 3: Java Abstraction

abstract class MotorBike {
  abstract void brake();
}

class SportsBike extends MotorBike {

  // implementation of abstract method
  public void brake() {
    System.out.println("SportsBike Brake");
  }
}

class MountainBike extends MotorBike {

  // implementation of abstract method
  public void brake() {
    System.out.println("MountainBike Brake");
  }
}

class Main {
  public static void main(String[] args) {
    MountainBike m1 = new MountainBike();
    m1.brake();
    SportsBike s1 = new SportsBike();
    s1.brake();
  }
}

Output:

MountainBike Brake
SportsBike Brake

In the above example, we have created an abstract super class MotorBike. The superclass MotorBike has an abstract method brake().

The brake() method cannot be implemented inside MotorBike. It is because every bike has different implementation of brakes. So, all the subclasses of MotorBike would have different implementation of brake().

So, the implementation of brake() in MotorBike is kept hidden.

Here, MountainBike makes its own implementation of brake() and SportsBike makes its own implementation of brake().

Note: We can also use interfaces to achieve abstraction in Java. To learn more, visit Java Interface.

Key Points to Remember

We use the abstract keyword to create abstract classes and methods.
An abstract method doesn't have any implementation (method body).
A class containing abstract methods should also be abstract.
We cannot create objects of an abstract class.
To implement features of an abstract class, we inherit subclasses from it and create objects of the subclass.
A subclass must override all abstract methods of an abstract class. However, if the subclass is declared abstract, it's not mandatory to override abstract methods.
We can access the static attributes and methods of an abstract class using the reference of the abstract class. For example,

Animal.staticMethod();

Connecting Java with PostgreSQL Using JDBC

PRIYA K — Mon, 22 Jun 2026 16:45:10 +0000

JDBC (Java Database Connectivity) is an API that enables Java applications to communicate with databases. It provides methods to establish a connection, execute SQL queries, and retrieve data from the database. In this project, PostgreSQL is used as the database management system, and Maven is used to manage project dependencies.

Creating a Maven Project in Eclipse
To begin, open Eclipse and create a new Maven project by following these steps:

Go to File → New → Project.
Select Maven Project and click Next.
Choose the default workspace location and continue.
Enter the project details:
Group ID: jdbc (package name)
Artifact ID: sampleProject
Version: 0.0.1-SNAPSHOT
Click Finish to create the project.

After the project is created, create a Java class inside the src/main/java folder by right-clicking the package and selecting:

New → Class

Adding PostgreSQL JDBC Dependency

When a Maven project is created, Eclipse automatically generates a pom.xml file. This file is used to manage external libraries and dependencies required by the project.

To connect Java with PostgreSQL, the PostgreSQL JDBC driver dependency must be added to the pom.xml file.

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0
         https://maven.apache.org/xsd/maven-4.0.0.xsd">

    <modelVersion>4.0.0</modelVersion>

    <groupId>jdbc</groupId>
    <artifactId>sampleProject</artifactId>
    <version>0.0.1-SNAPSHOT</version>

    <dependencies>
        <dependency>
            <groupId>org.postgresql</groupId>
            <artifactId>postgresql</artifactId>
            <version>42.7.7</version>
        </dependency>
    </dependencies>

</project>

After saving the pom.xml file, Maven automatically downloads the PostgreSQL JDBC driver and adds it to the project.

Task Description
Create a Java application that connects to a PostgreSQL database using JDBC. Assume that the database contains two tables: India Players and Afghanistan Players. Each table should store the player's name and score.

Insert at least three records into each table. Using Java and JDBC, retrieve the data from both tables and display the player names along with their scores on the console.

Requirements

Connect Java with PostgreSQL using JDBC.
Create two tables:
- india_players
- afghanistan_players
Store the following details in each table:
- Player Name
- Score
Insert a minimum of three records into each table.
Fetch the records from both tables using Java.
Display the retrieved data in the output.

Creating Tables in PostgreSQL Using the Linux Terminal

After setting up the Java Maven project, the next step is to create the database and tables in PostgreSQL using the Linux terminal.

Step 1: Open the Terminal
Open the Linux terminal and log in to PostgreSQL using:

sudo -u postgres psql

Once connected, the PostgreSQL prompt appears:

postgres=#

Step 2: Create a Database
Create a database named cricketdb:

CREATE DATABASE cricketdb;

Switch to the newly created database:

\c cricketdb

The prompt changes to:

cricketdb=#

Step 3: Create the Afghanistan Players Table

Create the table:

CREATE TABLE afghanistan_players (
    player_name VARCHAR(50),
    score INT
);

Insert sample records:

INSERT INTO afghanistan_players VALUES
('Rahmanullah Gurbaz', 78),
('Rashid Khan', 45),
('Mohammad Nabi', 60);

Step 4: Create the India Players Table
Create the table:

CREATE TABLE india_players (
    player_name VARCHAR(50),
    score INT
);

Insert sample records:

INSERT INTO india_players VALUES
('Virat Kohli', 92),
('Rohit Sharma', 75),
('Shubman Gill', 64);

Step 5: View the Data
To display the records stored in the tables, execute:

SELECT * FROM india_players;

SELECT * FROM afghanistan_players;

Step 6: Exit PostgreSQL
To leave the PostgreSQL shell, type:

\q

Using these commands, the database and tables are created successfully in PostgreSQL through the Linux terminal. The data stored in these tables can then be accessed from Java using JDBC.

Project Structure

In Eclipse:

sampleProject
│
├── src/main/java
│     └── sampleproject (package)
│            └── cricketdb.java (class)
│
└── pom.xml

sample project(package)-> src -> cricketdb(new class)

Java Program

package sampleProject;

import java.sql.*;

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

        String url = "jdbc:postgresql://localhost:5432/cricketdb";
        String user = "postgres";
        String password = "Welcome@123";

        try {
            Connection con = DriverManager.getConnection(url, user, password);

            // India Players
            System.out.println("INDIA PLAYERS");
            Statement st1 = con.createStatement();
            ResultSet rs1 = st1.executeQuery("SELECT * FROM india_players");

            while(rs1.next()) {
                System.out.println(
                    rs1.getString("player_name") +
                    " - " +
                    rs1.getInt("score")
                );
            }

            System.out.println("\nAFGHANISTAN PLAYERS");

            // Afghanistan Players
            Statement st2 = con.createStatement();
            ResultSet rs2 = st2.executeQuery("SELECT * FROM afghanistan_players");

            while(rs2.next()) {
                System.out.println(
                    rs2.getString("player_name") +
                    " - " +
                    rs2.getInt("score")
                );
            }

            con.close();

        } catch(Exception e) {
            System.out.println(e);
        }
    }
}

Output

Need to Know
Connecting Java with PostgreSQL

The database connection was established using JDBC.

String url = "jdbc:postgresql://localhost:5432/cricketdb";
String user = "postgres";
String password = "your_password";

Connection con = DriverManager.getConnection(url, user, password);

Password Authentication Error

During execution, the following exception occurred:

org.postgresql.util.PSQLException:
FATAL: password authentication failed for user "postgres"

This error occurred because the password provided in the Java program did not match the PostgreSQL user's password.

The issue was resolved by resetting the PostgreSQL password:

ALTER USER postgres PASSWORD 'admin123';

The same password was then used inside the Java program.

Testing the Database Connection

The PostgreSQL connection was verified using:

psql -U postgres -d cricketdb -W

Successful authentication confirmed that the database credentials were correct.

Updating the Maven Project
If the dependency is not downloaded automatically, right-click the project and select:

Maven → Update Project → Finish

This refreshes the project and downloads all required libraries.

XML Validation Issue

While editing the pom.xml file, the following warning appeared:

Cannot find the declaration of element 'project'

This is usually an XML validation issue and does not affect the execution of the Maven project. Updating the Maven project or running mvn clean install resolves the issue in most cases.

Conclusion

JDBC provides a simple and efficient way to connect Java applications with PostgreSQL databases. Maven simplifies dependency management, while PostgreSQL offers reliable data storage. Proper configuration of the JDBC driver and database credentials ensures successful communication between Java and PostgreSQL.

Abstraction in Java

PRIYA K — Sun, 21 Jun 2026 18:10:08 +0000

In Java, abstraction means showing only the important functionality and hiding the internal implementation details.

In simple terms:
You use something without needing to know how it works internally.

Real-life example
A fan:
You press the switch → fan turns on.
You don’t need to know how the motor and wiring work inside.
That’s abstraction.

Abstraction is usually implemented using:
abstract class
interface

Abstract class example

abstract class Vehicle {
    abstract void start();   // abstract method
}

class Bike extends Vehicle {
    void start() {
        System.out.println("Bike starts with self-start");
    }
}

public class Main {
    public static void main(String[] args) {
        Vehicle v = new Bike();
        v.start();
    }
}

Output
Bike starts with self-start

How abstraction works here
Vehicle defines what all vehicles should do:
every vehicle should have start()
But it does not say how.
The child class Bike gives the actual implementation.
So:
Parent class hides implementation details
Child class provides them

Why abstraction is used
hide unnecessary details
reduce complexity
improve security
make code easier to maintain
Simple explanation

Suppose:
Animal is abstract
Dog, Cat are concrete classes
All animals make sound, but each sound is different.
So:

abstract class Animal {
    abstract void sound();
}

This tells every child class:
“You must implement your own sound.”

Key points
Abstract class cannot create objects directly
It may contain abstract and normal methods
Used to achieve abstraction

why abstract can't create objects
An abstract class cannot create objects because it is incomplete by design.

It may contain abstract methods — methods that are declared but have no implementation yet.

Example:

abstract class Animal {
    abstract void sound();
}

Here sound() has no body. Java only knows:
the method name exists
but not what it should actually do

So if you tried to create an object:

Animal a = new Animal();   // error

Java would have a problem:
If someone calls a.sound(), what code should run?

There is no implementation yet.
That’s why Java blocks object creation for abstract classes.

Simple reason
An object should represent a fully usable thing.
But an abstract class is like a partial blueprint — it may still have unfinished parts.

So Java says:
complete class → object can be created
abstract class → object cannot be created directly

Real-life analogy
Think of a general idea like “Vehicle”.
A vehicle can:
start
stop

But “Vehicle” is just a general concept. You don’t buy a generic vehicle object in real life. You buy a specific:
Car
Bike

Same in Java:
Vehicle (abstract) → no object
Car, Bike (concrete subclasses) → object can be created

Example
abstract class Vehicle {
abstract void start();
}

class Car extends Vehicle {
void start() {
System.out.println("Car starts");
}
}

public class Main {
public static void main(String[] args) {
Vehicle v = new Car();
v.start();
}
}

Here:

Vehicle cannot create object
Car can, because it completes the abstract method
One-line answer

Abstract classes cannot create objects because they may contain incomplete methods, and Java requires an object to have complete behavior before it can be instantiated.

Encapsulation in Java

PRIYA K — Sun, 21 Jun 2026 16:39:08 +0000

read gfg,w3schools,tutorialpoint

Encapsulation in Java is the process of bundling data (variables) and the methods that operate on that data into a single unit, typically a class. It is one of the four fundamental principles of Object-Oriented Programming (OOP). The other three are inheritance, polymorphism, and abstraction.

Encapsulation refers to the bundling of fields and methods inside a single class.
It prevents outer classes from accessing and changing fields and methods of a class. This also helps to achieve data hiding.

Encapsulation in Java is a mechanism of wrapping the data (variables) and code acting on the data (methods) together as a single unit. In encapsulation, the variables of a class will be hidden from other classes, and can be accessed only through the methods of their current class. Therefore, it is also known as data hiding.

It restricts direct access to data by hiding implementation details. This ensures controlled interaction with the data through defined methods.
This encapsulation mechanism protects the internal state of the Programmer object and allows for better control and flexibility in how the name attribute is accessed and modified.

Achieved using access modifiers like private, protected, and public.
Improves data security by allowing validation through getters and setters.
Enhances code maintainability by isolating changes within the class.

we use the encapsulation and use getter (getName) and setter (setName) method which are used to show and modify the private data.

This encapsulation mechanism protects the internal state of the Programmer object and allows for better control and flexibility in how the name attribute is accessed and modified.

to make sure that "sensitive" data is hidden from users. To achieve this, you must:
declare class variables/attributes as private
provide public get and set methods to access and update the value of a private variable

encapsulation vs data hiding
Encapsulation refers to the bundling of related fields and methods together. This can be used to achieve data hiding. Encapsulation in itself is not data hiding.

Why Encapsulation?

In Java, encapsulation helps us to keep related fields and methods together, which makes our code cleaner and easy to read.
It helps to control the values of our data fields
Better control of class attributes and methods
Class attributes can be made read-only (if you only use the get method), or write-only (if you only use the set method)
Flexible: the programmer can change one part of the code without affecting other parts
Increased security of data

Get and Set
private variables can only be accessed within the same class (an outside class has no access to it). However, it is possible to access them if we provide public get and set methods.

The get method returns the variable value, and the set method sets the value.
The set method takes a parameter (newName) and assigns it to the name variable.
The this keyword is used to refer to the current object.

However, as the name variable is declared as private, we cannot access it from outside this class:

Syntax for both is that they start with either get or set, followed by the name of the variable, with the first letter in upper case.

Benefits of Encapsulation
The fields of a class can be made read-only or write-only.
A class can have total control over what is stored in its fields.

Java Encapsulation: Read-Only Class
A read-only class can have only getter methods to get the values of the attributes, there should not be any setter method.

Java Encapsulation: Write-Only Class
A write-only class can have only setter methods to set the values of the attributes, there should not be any getter method.

The getter and setter methods provide read-only or write-only access to our class fields. For example,

getName() // provides read-only access
setName() // provides write-only access

It helps to decouple components of a system. For example, we can encapsulate code into multiple bundles.

These decoupled components (bundle) can be developed, tested, and debugged independently and concurrently. And, any changes in a particular component do not have any effect on other components.
We can also achieve data hiding using encapsulation.
if we change the variable into private,then the access to these fields is restricted. and they are kept hidden from outer classes. This is called data hiding.

How to Implement Encapsulation
To achieve encapsulation in Java, you follow two main steps:
1.Declare variables as private: This hides the data from direct access by any code outside the class
2.Provide public getter and setter methods: These methods allow other classes to read or modify the private variables in a controlled and safe manner.

Achieving Encapsulation in Java
Declare the variables of a class as private or Private data members.
Provide public setter and getter methods to modify and view the variables values.

Key Rules:
Declare data as private: Hide the class data so it cannot be accessed directly from outside the class.
Use getters and setters: Keep variables private and provide public getter and setter methods for controlled access and safe modification, often with validation.
Apply proper access modifiers: Use private for data hiding and public for methods that provide access.

Advantages of Encapsulation
Data Hiding: Encapsulation restricts direct access to class variables, protecting sensitive data from unauthorized access.
Improved Maintainability: Changes to internal implementation can be made without affecting external code that uses the class.
Enhanced Security: Encapsulation allows validation and control over data, preventing invalid or harmful values from being set.
Code Reusability: Encapsulated classes can be reused in different programs without exposing internal logic.
Better Modularity:Encapsulation promotes organized, modular code by keeping data and methods together within a class.

Disadvantages of Encapsulation
Increased Code Complexity: Writing getter and setter methods for every variable can make the code longer and slightly more complex.
Performance Overhead: Accessing data through methods instead of directly can introduce a minor performance cost, especially in performance-critical applications.
Less Flexibility in Some Cases: Over-restricting access to class members may limit the ability of other classes to extend or use the class efficiently.

Data Hiding vs Encapsulation
*Data Hiding *
Definition: Restricting direct access to data to protect it from unauthorized use.
Focus:Security of data

Purpose:Prevents misuse and accidental modification of data
How it is achieved:Using access modifiers (private, protected)

Involves methods:No (mainly focuses on data)

Scope:Narrow concept

Dependency:Independent concept

Example :private int balance;

Encapsulation
Definition:Wrapping data and methods into a single unit (class)
Focus:Structure and design
Purpose:Improves modularity and maintainability
How it is achieved:Using classes, methods, and access modifiers
Involves methods:Yes (includes both data and methods)
Scope:Broader concept
Dependency:Encapsulation may use data hiding.for better security but it is not mandatory.
Example:
class Account { private int balance; public getBalance(); }

Example

public class Person {
    // 1. Private data members
    private String name;

    // 2. Public Getter method
    public String getName() {
        return name;
    }

    // 3. Public Setter method
    public void setName(String newName) {
        this.name = newName;
    }
}

name is private, it cannot be accessed directly; instead, it must be accessed via getName() and modified via setName()

Data Hiding
Data hiding is a way of restricting the access of our data members by hiding the implementation details. Encapsulation also provides a way for data hiding.
We can use access modifiers to achieve data hiding. For example,
Example 2: Data hiding using the private specifier

class Person {
  // private field
  private int age;
  // getter method
  public int getAge() {
    return age;
  }
  // setter method
  public void setAge(int age) {
    this.age = age;
  }
}
class Main {
  public static void main(String[] args) {
    // create an object of Person
    Person p1 = new Person();
    // change age using setter
    p1.setAge(24);
    // access age using getter
    System.out.println("My age is " + p1.getAge());
  }
}

Output
My age is 24

In the above example, we have a private field age. Since it is private, it cannot be accessed from outside the class.

In order to access age, we have used public methods: getAge() and setAge(). These methods are called getter and setter methods.

Making age private allowed us to restrict unauthorized access from outside the class. This is data hiding.

If we try to access the age field from the Main class, we will get an error.

// error: age has private access in Person
p1.age = 24;

Dynamic Binding,Static Binding

PRIYA K — Sun, 21 Jun 2026 15:21:13 +0000

Binding
Binding is a mechanism creating link between method call and method actual implementation. As per the polymorphism concept in Java, object can have many different forms. Object forms can be resolved at compile time and run time.

Java Dynamic Binding

Dynamic binding refers to the process in which linking between method call and method implementation is resolved at run time (or, a process of calling an overridden method at run time). Dynamic binding is also known as run-time polymorphism or late binding. Dynamic binding uses objects to resolve binding.

In Dynamic binding compiler doesn't decide the method to be called. In overriding both parent and child classes have the same method.

example
Methods are not static.
During compilation, the compiler has no idea as to which print has to be called since the compiler goes only by referencing variable not by the type of object, and therefore the binding would be delayed to runtime and therefore the corresponding version of the print will be called based on type on an object.

Characteristics of Java Dynamic Binding

Linking − Linking between method call and method implementation is resolved at run time.
Resolve mechanism − Dynamic binding uses object type to resolve binding.
Example − Method overriding is the example of Dynamic binding.
Type of Methods − Virtual methods use dynamic binding.

Example of Java Dynamic Binding
we've created two classes Animal and Dog where Dog class extends Animal class. In main() method, we're using Animal class reference and assign it an object of Dog class to check Dynamic binding effect.

package com.tutorialspoint;
class Animal {
   public void move() {
      System.out.println("Animals can move");
   }
}
class Dog extends Animal {
   public void move() {
      System.out.println("Dogs can walk and run");
   }
}
public class Tester {
   public static void main(String args[]) {
      Animal a = new Animal();   // Animal reference and object
      // Dynamic Binding      
      Animal b = new Dog();   // Animal reference but Dog object
      a.move();   // runs the method in Animal class
      b.move();   // runs the method in Dog class
   }
}

Output
Animals can move
Dogs can walk and run

Explanation:
b is a type of Animal it runs the move method in the Dog class. The reason for this is: In compile time, the check is made on the reference type. However, in the runtime, JVM figures out the object type and would run the method that belongs to that particular object.

the program will compile properly since Animal class has the method move. Then, at the runtime, it runs the method specific for that object.

Java Dynamic Binding: Using the super Keyword
When invoking a superclass version of an overridden method the super keyword is used so that we can utilize parent class method while using dynamic binding.

Example: Using the super Keyword

we've created two classes Animal and Dog where Dog class extends Animal class. Dog class overrides the move method of its super class Animal. But it calls parent move() method using super keyword so that both move methods are called when child method is called due to dynamic binding. In main() method, we're using Animal class reference and assign it an object of Dog class to check Dynamic binding effect.

class Animal {
   public void move() {
      System.out.println("Animals can move");
   }
}
class Dog extends Animal {
   public void move() {
      super.move();   // invokes the super class method
      System.out.println("Dogs can walk and run");
   }
}
public class TestDog {
   public static void main(String args[]) {
      Animal b = new Dog();   // Animal reference but Dog object
      b.move();   // runs the method in Dog class
   }
}

Output
Animals can move
Dogs can walk and run

Java Static Binding
Static binding refers to the process in which linking between method call and method implementation is resolved at compile time. Static binding is also known as compile-time binding or early binding.

The binding which can be resolved at compile time by the compiler is known as static or early binding. The binding of all the static, private, and final methods is done at compile-time.

example
We have created one object of subclass and one object of the superclass with the reference of the superclass.
Since the print method of the superclass is static, the compiler knows that it will not be overridden in subclasses and hence compiler knows during compile time which print method to call and hence no ambiguity.

Characteristics of Java Static Binding

Linking − Linking between method call and method implementation is resolved at compile time.
Resolve mechanism − Static binding uses type of the class and fields to resolve binding.
Example − Method overloading is the example of Static binding.
Type of Methods − private, final and static methods and variables uses static binding.

Example of Java Static Binding

we've created a Calculator class having two static methods with same name but different arguments to add two and three int values respectively. In main() method, we're calling these methods and printing the result. Based on the number of arguments passed, compiler decides the method using static binding which method is to be called and result is printed accordingly.

package com.tutorialspoint;
class Calculator{
   public static int add(int a, int b){
      return a + b;
   }
   public static int add(int a, int b, int c){
      return a + b + c;
   }
}
public class Tester {
   public static void main(String args[]){
      System.out.println(Calculator.add(20, 40));
      System.out.println(Calculator.add(40, 50, 60));
   }
}

Output
60
150

*why binding of static, final, and private methods is always static binding? *

Static binding is better performance-wise (no extra overhead is required). The compiler knows that all such methods cannot be overridden and will always be accessed by objects of the local class. Hence compiler doesn’t have any difficulty determining the object of the class (local class for sure). That’s the reason binding for such methods is static.

differences between static and dynamic binding **
**Static Binding

It takes place at compile time for which is referred to as early binding
It uses overloading more precisely operator overloading method .Overloaded methods are resolved (deciding which method to be called when there are multiple methods with the same name) using static binding
It takes place using normal functions
private functions, final ,const and static members (methods and variables) use real objects in static binding.
The static binding uses Type information for binding

Dynamic Binding
It takes place at runtime so do it is referred to as late binding.
It uses overriding methods.
It takes place using virtual functions.virtual methods (In Java methods are virtual by default) binding is done during run time based upon the run time object.
Real objects use dynamic binding.
Dynamic binding uses Objects to resolve to bind.

Polymorphism in java

PRIYA K — Sun, 21 Jun 2026 11:59:24 +0000

read gfg,tutorialpoint,w3schools

Polymorphism is one of the fundamental concepts of Object-Oriented Programming (OOP) that allows a single entity to take multiple forms. It enables the same method or interface to behave differently depending on the object involved. Polymorphism improves code flexibility, reusability, and maintainability.

Polymorphism is an important feature of Java OOPs concept and it allows us to perform multiple operations by using the single name of any method (interface). Any Java object that can pass more than one IS-A test is considered to be polymorphic. In Java, all Java objects are polymorphic since any object will pass the IS-A test for its own type and for the class Object.

The word polymorphism means having multiple forms. The term Polymorphism gets derived from the Greek word where poly + morphos where poly means many and morphos means forms.

Polymorphism means "many forms".
It allows the same method to exhibit different behaviors.
It is achieved through method overloading and method overriding.

Polymorphism is another special feature of object-oriented programming (OOPs). The approach which lies beneath this concept is "single interface with multiple implementations." It offers a single interface for controlling access to a general class of actions.

Polymorphism can be achieved in two of the following ways:
Method Overloading(Compile time Polymorphism)
Method Overriding(Run time Polymorphism)

Static Polymorphism is in other words termed as compile-time binding or early binding.
Static binding occurs at compile time. Method overloading is a case of static binding and in this case binding of method call to its definition happens at the time of compilation

That is, the same entity (method or operator or object) can perform different operations in different scenarios

polymorphism in Java allows us to create a single method
that will behave differently

Use of Polymorphism in Java
The most common use of polymorphism in OOP occurs when a parent class reference is used to refer to a child class object.

It is important to know that the only possible way to access an object is through a reference variable. A reference variable can be of only one type. Once declared, the type of a reference variable cannot be changed.

The reference variable can be reassigned to other objects provided that it is not declared final. The type of the reference variable would determine the methods that it can invoke on the object.

A reference variable can refer to any object of its declared type or any subtype of its declared type. A reference variable can be declared as a class or interface type.

Java Polymorphism Example

public interface Vegetarian{}
public class Animal{}
public class Deer extends Animal implements Vegetarian{}

Now, the Deer class is considered to be polymorphic since this has multiple inheritance. Following are true for the above examples −

A Deer IS-A Animal
A Deer IS-A Vegetarian
A Deer IS-A Deer
A Deer IS-A Object

When we apply the reference variable facts to a Deer object reference, the following declarations are legal −

Deer d = new Deer();
Animal a = d;
Vegetarian v = d;
Object o = d;

All the reference variables d, a, v, o refer to the same Deer object in the heap.

Java Polymorphism Implementation
we're showcasing the above concept by creating the object of a Deer and assigning the same to the references of superclasses or implemented interface.

interface Vegetarian{}
class Animal{}
public class Deer extends Animal implements Vegetarian{
    public static void main(String[] args) {
        Deer d = new Deer();
        Animal a = d;
        Vegetarian v = d;
        Object o = d;
        System.out.println(d instanceof Deer);
        System.out.println(a instanceof Deer);
        System.out.println(v instanceof Deer);
        System.out.println(o instanceof Deer);
    }   
}

Output
true
true
true
true

1. Compile-Time Polymorphism
Compile-time polymorphism also known as static polymorphism, occurs when the method to be executed is determined during compilation. The method that is called is determined by the compiler. Hence, it is also known as compile-time polymorphism.It is primarily achieved through method overloading.
Method selection occurs at compile time.
Improves readability and flexibility.
Compile-time polymorphism is also known as static polymorphism and it is implemented by method overloading.

Method Overloading
Method overloading allows multiple methods with the same name but different parameter lists within the same class. The compiler chooses the appropriate method based on the arguments passed.

The same method will perform different operations based on the parameter.

To call an overloaded method in Java, it is must use the type and/or the number of arguments to determine which version of the overloaded method actually to call.
The overloaded methods may have varied return types and the return type single-handedly is insufficient to make out two versions of a method.
As and when Java compiler encounters a call to an overloaded method, it simply executes the version of the method whose parameters match the arguments used in the call.
It permits the user to obtain compile time polymorphism with name method name.
An overloaded method can throw different kinds of exceptions.
A method which is overloaded can contain different access modifiers.

Syntax:

    class Demo {
     void show(int a) {
     }
      void show(int a, int b) {
      }
    }

Example: Method overloading by changing the number of arguments

class Helper {
    static int Multiply(int a, int b)
    {
        return a * b;
    }
    static double Multiply(double a, double b)
    {
        return a * b;
    }
}

class Geeks {
    public static void main(String[] args)
    {
        System.out.println(Helper.Multiply(2, 4));
        System.out.println(Helper.Multiply(5.5, 6.3));
    }
}

Explanation: The Multiply method is overloaded with different parameter types. The compiler picks the correct method during compile time based on the arguments.

Variations in Overloading a Method
Overloading method's argument lists might differ in:
Number of parameters passed
Data type of actual parameters
Sequence of data type of actual parameters

2. Runtime Polymorphism
Runtime polymorphism also known as dynamic polymorphism, occurs when the method call is resolved during program execution. It is achieved through method overriding.

Run time polymorphism is also known as dynamic method dispatch and it is implemented by the method overriding.
Method selection occurs at runtime.
Depends on the actual object type.

Method Overriding
Method overriding occurs when a subclass provides its own implementation of a method already defined in its superclass. The overridden method is selected based on the actual object created.

Syntax:

    class Parent {
     void print() {
     }
    }

    class Child extends Parent {
    @Override
    void print() {
     }
    }

Note: At runtime, the method that gets executed depends on the actual object type, not the reference type.

Explanation: when an object of a child class is created, then the method inside the child class is called. This is because the method in the parent class is overridden by the child class. At runtime, the JVM determines which method to execute based on the actual type of the object, not the reference type. If the object is of a child class, the overridden method in the child class is invoked.

Method Overriding
During inheritance in Java, if the same method is present in both the superclass and the subclass. Then, the method in the subclass overrides the same method in the superclass. This is called method overriding.

In this case, the same method will perform one operation in the superclass and another operation in the subclass.

Note: The method that is called is determined during the execution of the program. Hence, method overriding is a run-time polymorphism.

Rules Of Method Overriding
Argument list: The argument list at the time of overriding method need to be same as that of the method of the parent class. The data types of the arguments along with their sequence must have to be preserved as it is in the overriding method.
Access Modifier: The Access Modifier present in the overriding method (method of subclass) cannot be more restrictive than that of an overridden method of the parent class.
The private, static and final methods can't be overridden as they are local to the class.
Any method which is overriding can throw any unchecked exceptions, in spite of whether the overridden method usually method of parent class might throw an exception or not.

Example

class parent {
 public void work() {
  System.out.println("Parent is under retirement from work.");
 }
}
class child extends parent {
 public void work() {
  System.out.println("Child has a job");
  System.out.println(" He is doing it well");
 }
 public static void main(String argu[]) {
  child c1 = new child();
  c1.work();
 }
}

Virtual Method and Run Time Polymorphism in Java
where a child class can override a method in its parent. An overridden method is essentially hidden in the parent class, and is not invoked unless the child class uses the super keyword within the overriding method.

This behavior is referred to as virtual method invocation, and these methods are referred to as virtual methods. An overridden method is invoked at run time, no matter what data type the reference is that was used in the source code at compile time.

Advantage of Method Overriding
A class can give its specific execution to an inherited method without having the modification in the parent class (base class).

Java Polymorphism and Inheritance

Polymorphism means "many forms", and it occurs when we have many classes that are related to each other by inheritance.

Inheritance lets us inherit attributes and methods from another class. Polymorphism uses those methods to perform different tasks. This allows us to perform a single action in different ways.

Inheritance:use the extends keyword to inherit from a class.

Why And When To Use "Inheritance" and "Polymorphism"?

It is useful for code reusability: reuse attributes and methods of an existing class when you create a new class.

Advantages of Polymorphism
Code Reusability: The same method or class works with different object types.
Flexibility: Different objects can be treated as a common superclass type.
Abstraction: Enables working with general types (abstract classes or interfaces) instead of concrete classes.
Dynamic Behavior: Method calls are resolved at runtime based on the actual object type.

Disadvantages of Polymorphism
It can make more difficult to understand the behavior of an object.
This may cause performance issues, as polymorphic behavior may require additional computations at runtime.

Packages in Java

PRIYA K — Sun, 21 Jun 2026 03:57:11 +0000

read gfg,tutorialpoint,w3schools

A package in Java is a mechanism to group related classes, interfaces, and sub-packages into a single unit.
Packages help organize large applications, avoid naming conflicts, provide access protection, and make code modular and maintainable.

Avoiding name conflicts (two classes with the same name can exist in different packages)
Providing access control using public, protected, and default access
Reusability: packaged code can be imported and used anywhere
Encouraging modular programming

It is a good practice to use names of packages with lower case letters to avoid any conflicts with the names of classes and interfaces.

Think of it as a folder in a file directory.

Packages are used in Java in order to prevent naming conflicts, control access, make searching/locating and usage of classes, interfaces, enumerations, and annotations easier, etc.

A package is simply a container that groups related types (Java classes, interfaces, enumerations, and annotations). providing access protection and namespace management.

For example, in core Java, the ResultSet interface belongs to the java.sql package. The package contains all the related types that are needed for the SQL query and database connection.

If you want to use the ResultSet interface in your code, just import the java.sql package (Importing packages will be discussed later in the article).

packages are just containers for Java classes, interfaces and so on. These packages help you to reserve the class namespace and create a maintainable code.

For example, you can find two Date classes in Java. However, the rule of thumb in Java programming is that only one unique class name is allowed in a Java project.

How did they manage to include two classes with the same name Date in JDK?

This was possible because these two Date classes belong to two different packages:
java.util.Date - this is a normal Date class that can be used anywhere.
java.sql.Date - this is a SQL Date used for the SQL query and such.

Types of Java Package
Built-in Packages (packages from the Java API)
User-defined Packages (create your own packages)

Some of the existing packages in Java are −
java.lang − bundles the fundamental classes
java.io − classes for input , output functions are bundled in this package

1. Built-in Packages
Built-in Packages comprise a large number of classes that are part of the Java API.
The Java API is a library of prewritten classes, that are free to use, included in the Java Development Environment.

The library contains components for managing input, database programming, and much much more.

The library is divided into packages and classes. Meaning you can either import a single class (along with its methods and attributes), or a whole package that contain all the classes that belong to the specified package.

Built-in packages are existing java packages that come along with the JDK. For example, java.lang, java.util, java.io, etc. For example:

import java.util.ArrayList;
class ArrayListUtilization {
    public static void main(String[] args) {
        ArrayList<Integer> myList = new ArrayList<>(3);
        myList.add(3);
        myList.add(2);
        myList.add(1);
        System.out.println(myList);
    }
}

Output:
myList = [3, 2, 1]

The ArrayList class belongs to java.util package. To use it, we have to import the package first using the import statement.

import java.util.ArrayList;

To use a class or a package from the library, you need to use the import keyword:

Syntax
import package.name.Class; // Import a single class
import package.name.*; // Import the whole package

Import a Class
If you find a class you want to use, for example, the Scanner class, which is used to get user input, write the following code:
Example

import java.util.Scanner;

java.util is a package, while Scanner is a class of the java.util package.

To use the Scanner class, create an object of the class and use any of the available methods found in the Scanner class documentation. we will use the nextLine() method, which is used to read a complete line:

Example

Using the Scanner class to get user input:

import java.util.Scanner;
class Main {
  public static void main(String[] args) {
    Scanner myObj = new Scanner(System.in);
    System.out.println("Enter username");
    String userName = myObj.nextLine();
    System.out.println("Username is: " + userName);
  }
}

Import a Package
There are many packages to choose from. we used the Scanner class from the java.util package. This package also contains date and time facilities, random-number generator and other utility classes.

To import a whole package, end the sentence with an asterisk sign (). The following example will import ALL the classes in the java.util package:
**Example*

import java.util.*;

2. User-defined Packages

To create your own package, you need to understand that Java uses a file system directory to store them. Just like folders on your computer:
Example

└── root
  └── mypack
    └── MyPackageClass.java

To create a package, use the package keyword:

MyPackageClass.java

package mypack;
class MyPackageClass {
  public static void main(String[] args) {
    System.out.println("This is my package!");
  }
}

Save the file as MyPackageClass.java, and compile it:

C:\Users\Your Name>javac MyPackageClass.java

Then compile the package:

C:\Users\Your Name>javac -d . MyPackageClass.java

This forces the compiler to create the "mypack" package.

The -d keyword specifies the destination for where to save the class file. You can use any directory name, like c:/user (windows), or, if you want to keep the package within the same directory, you can use the dot sign ".", like in the example above.

Note: The package name should be written in lower case to avoid conflict with class names.

When we compiled the package in the example above, a new folder was created, called "mypack".

To run the MyPackageClass.java file, write the following:
C:\Users\Your Name>java mypack.MyPackageClass

The output will be:
This is my package!

Some of the commonly used built-in packages are:

java.lang: Contains language support classes(e.g, classes that define primitive data types, math operations). This package is automatically imported.
java.io: Contains classes for supporting input/output operations.
java.util: Contains utility classes that implement data structures such as Linked Lists and Dictionaries, as well as support for date and time operations.
java.applet: Contains classes for creating Applets.
java.awt: Contains classes for implementing the components for graphical user interfaces (like buttons, menus, etc)

Example: Using java.util.Random (Built-in Package)

import java.util.Random;   // built-in package
public class GFG{ 
    public static void main(String[] args) {   
        // using Random class
        Random rand = new Random();   
        // generates a number between 0–99
        int number = rand.nextInt(100);  
        System.out.println("Random number: " + number);
    }
}

Output
Random number: 59

User-defined Packages are the packages that are defined by the user.

You can define your own packages to bundle groups of classes/interfaces, etc. It is a good practice to group related classes implemented by you so that a programmer can easily determine that the classes, interfaces, enumerations, and annotations are related.

Since the package creates a new namespace there won't be any name conflicts with names in other packages. Using packages, it is easier to provide access control and it is also easier to locate the related classes.

Java also allows you to create packages as per your need. These packages are called user-defined packages.
How to define a Java package?

To define a package in Java, you use the keyword package.

package packageName;

Java uses file system directories to store packages. Let's create a Java file inside another directory.

For example:

└── com
└── test
└── Test.java

Now, edit Test.java file, and at the beginning of the file, write the package statement as:

package com.test;

Here, any class that is declared within the test directory belongs to the com.test package.

Here's the code:

package com.test;

class Test {
public static void main(String[] args){
System.out.println("Hello World!");
}
}

Output:
Hello World!

Here, the Test class now belongs to the com.test package.

Creating a Java Package

While creating a package, you should choose a name for the package and include a package statement along with that name at the top of every source file that contains the classes, interfaces, enumerations, and annotation types that you want to include in the package.

The package statement should be the first line in the source file. There can be only one package statement in each source file, and it applies to all types in the file.

If a package statement is not used then the class, interfaces, enumerations, and annotation types will be placed in the current default package.

Compiling with Java Package

To compile the Java programs with package statements, you have to use -d option as shown below.

javac -d Destination_folder file_name.java

Then a folder with the given package name is created in the specified destination, and the compiled class files will be placed in that folder.

Example:

package com.myapp;
public class Helper {
    public static void show() {
        System.out.println("Hello from Helper!");
    }
}

To use it in another class:

import com.myapp.Helper;
public class Test {
    public static void main(String[] args) {
        Helper.show();
    }
}

Accessing Classes Inside a Package

In Java, we can import classes from a package using either of the following methods:

1. Import a Single Class

import java.util.Vector;

This imports only the Vector class from the java.util package.

2. Import all classes from a package:

import java.util.*;

This imports all classes and interfaces from the java.util package but does not include sub-packages.

Example: Import the Vector class

import java.util.Vector;
public class Geeks {
    public Geeks() {
        // java.util.Vector is imported, We are able to access it directly in our code.
        Vector v = new Vector();
        java.util.ArrayList l = new java.util.ArrayList();
        l.add(3);
        l.add(5);
        l.add(7);
        System.out.println(l);
    }
    public static void main(String[] args) {
        new Geeks();
    }
}

Output
[3, 5, 7]

Directory Structure of a Java Package
Two major results occur when a class is placed in a package −
The name of the package becomes a part of the name of the class.
The name of the package must match the directory structure where the corresponding bytecode resides.

Here is simple way of managing your files in Java −

Put the source code for a class, interface, enumeration, or annotation type in a text file whose name is the simple name of the type and whose extension is .java.

For example −

// File Name : Car.java
package vehicle;

public class Car {
// Class implementation.

}

Now, put the source file in a directory whose name reflects the name of the package to which the class belongs −

....\vehicle\Car.java

Now, the qualified class name and pathname would be as follows −

Class name → vehicle.Car
Path name → vehicle\Car.java (in windows)

In general, a company uses its reversed Internet domain name for its package names.

Example − A company's Internet domain name is apple.com, then all its package names would start with com.apple. Each component of the package name corresponds to a subdirectory.

Example − The company had a com.apple.computers package that contained a Dell.java source file, it would be contained in a series of subdirectories like this −

....\com\apple\computers\Dell.java

At the time of compilation, the compiler creates a different output file for each class, interface and enumeration defined in it. The base name of the output file is the name of the type, and its extension is .class.

For example −

// File Name: Dell.java
package com.apple.computers;

public class Dell {
}

class Ups {
}

Now, compile this file as follows using -d option −

$javac -d . Dell.java

The files will be compiled as follows −

.\com\apple\computers\Dell.class
.\com\apple\computers\Ups.class

You can import all the classes or interfaces defined in \com\apple\computers\ as follows −

import com.apple.computers.*;

Like the .java source files, the compiled .class files should be in a series of directories that reflect the package name. However, the path to the .class files does not have to be the same as the path to the .java source files. You can arrange your source and class directories separately, as −

\sources\com\apple\computers\Dell.java

\classes\com\apple\computers\Dell.class

By doing this, it is possible to give access to the classes directory to other programmers without revealing your sources. You also need to manage source and class files in this manner so that the compiler and the Java Virtual Machine (JVM) can find all the types your program uses.

The full path to the classes directory, \classes, is called the class path, and is set with the CLASSPATH system variable. Both the compiler and the JVM construct the path to your .class files by adding the package name to the class path.

Say \classes is the class path, and the package name is com.apple.computers, then the compiler and JVM will look for .class files in \classes\com\apple\computers.

A class path may include several paths. Multiple paths should be separated by a semicolon (Windows) or colon (Unix). By default, the compiler and the JVM search the current directory and the JAR file containing the Java platform classes so that these directories are automatically in the class path.
Set CLASSPATH System Variable

To display the current CLASSPATH variable, use the following commands in Windows and UNIX (Bourne shell) −

In Windows → C:> set CLASSPATH
In UNIX → % echo $CLASSPATH

To delete the current contents of the CLASSPATH variable, use −

In Windows → C:> set CLASSPATH =
In UNIX → % unset CLASSPATH; export CLASSPATH

To set the CLASSPATH variable −

In Windows → set CLASSPATH = C:\users\jack\java\classes
In UNIX → % CLASSPATH = /home/jack/java/classes; export CLASSPATH

Package Naming convention

The package name must be unique (like a domain name). Hence, there's a convention to create a package as a domain name, but in reverse order. For example, com.company.name

Here, each level of the package is a directory in your file system. Like this:

└── com
└── company
└── name

And, there is no limitation on how many subdirectories (package hierarchy) you can create.
How to create a package in Intellij IDEA?

In IntelliJ IDEA, here's how you can create a package:

Right-click on the source folder.
Go to new and then package.
New package in Intellij IDEA

A pop-up box will appear where you can enter the package name.
Package Naming convention in Java

Once the package is created, a similar folder structure will be created on your file system as well. Now, you can create classes, interfaces, and so on inside the package.
Package directory

How to import packages in Java?

Java has an import statement that allows you to import an entire package (as in earlier examples), or use only certain classes and interfaces defined in the package.

The general form of import statement is:

import package.name.ClassName; // To import a certain class only
import package.name.* // To import the whole package

For example,

import java.util.Date; // imports only Date class
import java.io.*; // imports everything inside java.io package

The import statement is optional in Java.

If you want to use class/interface from a certain package, you can also use its fully qualified name, which includes its full package hierarchy.

Here is an example to import a package using the import statement.

import java.util.Date;

class MyClass implements Date {
// body
}

The same task can be done using the fully qualified name as follows:

class MyClass implements java.util.Date {
//body
}

Example: Package and importing package

Suppose, you have defined a package com.programiz that contains a class Helper.

package com.programiz;

public class Helper {
public static String getFormattedDollar (double value){
return String.format("$%.2f", value);
}
}

Now, you can import Helper class from com.programiz package to your implementation class. Once you import it, the class can be referred directly by its name. Here's how:

import com.programiz.Helper;

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

    double value = 99.5;
    String formattedValue = Helper.getFormattedDollar(value);
    System.out.println("formattedValue = " + formattedValue);
}

}

Output:

formattedValue = $99.50

Here,

the Helper class is defined in com.programiz package.
the Helper class is imported to a different file. The file contains UseHelper class.
The getFormattedDollar() method of the Helper class is called from inside the UseHelper class.

Importing packages in Java
Java import package

In Java, the import statement is written directly after the package statement (if it exists) and before the class definition.

For example,

package package.name;
import package.ClassName; // only import a Class

class MyClass {
// body
}

Constructor Overloading in java

PRIYA K — Sat, 20 Jun 2026 15:13:00 +0000

read gfg,tutorialpoint,programmiz

Java supports constructor overloading, which allows a class to have more than one constructor with different parameter lists. The appropriate constructor is selected at compile time based on the arguments passed during object creation. Constructor overloading enables objects to be initialized in multiple ways, improving flexibility and code clarity.
Yes! Java supports constructor overloading. In constructor loading, we create multiple constructors with the same name but with different parameters types or with different no of parameters.

Similar to Java method overloading, we can also create two or more constructors with different parameters. This is called constructor overloading.

When do we need Constructor Overloading?
Objects need to be initialized with different sets of data
Default values are required in some cases
Simplified object creation is desired for common use cases

Example:
The Thread class provides multiple constructors. For example:

  Thread t = new Thread("MyThread");

Example

class Main {
  String language;
  // constructor with no parameter
  Main() {
    this.language = "Java";
  }
  // constructor with a single parameter
  Main(String language) {
    this.language = language;
  }
  public void getName() {
    System.out.println("Programming Language: " + this.language);
  }
  public static void main(String[] args) {
    // call constructor with no parameter
    Main obj1 = new Main();
    // call constructor with a single parameter
    Main obj2 = new Main("Python");
    obj1.getName();
    obj2.getName();
  }
}

Output
Programming Language: Java
Programming Language: Python

In the above example, we have two constructors: Main() and Main(String language).
Here, both the constructors initialize the value of the variable language with different values.
Based on the parameter passed during object creation, different constructors are called, and different values are assigned.
It is also possible to call one constructor from another constructor. To learn more, visit Java Call One Constructor from Another.

Note: We have used this keyword to specify the variable of the class. To know more about this keyword, visit Java this keyword.

If no arguments are required, the default constructor can be used. If a thread name is needed, a parameterized constructor is selected automatically.

Problem Without Constructor Overloading

Consider a class Box with only one constructor:

class Box {
    double width, height, depth;

    Box(double w, double h, double d) {
        width = w;
        height = h;
        depth = d;
    }
    double volume() {
        return width * height * depth;
    }
}

In this case, the following statement is invalid:

Box box = new Box(); // Compile-time error

The class does not support creating:

An empty box
A cube using a single value

Example of Constructor Overloading
By adding multiple constructors, different initialization options become available.

class Box {
    double width, height, depth;
    Box(double w, double h, double d) {
        width = w;
        height = h;
        depth = d;
    }

    // No-argument constructor
    Box() {
        width = height = depth = 0;
    }
    // Constructor for cube
    Box(double len) {
        width = height = depth = len;
    }
    double volume() {
        return width * height * depth;
    }
}
// Driver class
public class Test {
    public static void main(String[] args) {
        Box mybox1 = new Box(10, 20, 15);
        Box mybox2 = new Box();
        Box mycube  = new Box(7);
        System.out.println("Volume of mybox1: " + mybox1.volume());
        System.out.println("Volume of mybox2: " + mybox2.volume());
        System.out.println("Volume of mycube: " + mycube.volume());
    }
}

Output
Volume of mybox1: 3000.0
Volume of mybox2: 0.0
Volume of mycube: 343.0

Using this() in Constructor Overloading
The this() keyword is used to call one constructor from another constructor in the same class. It helps avoid code duplication and ensures consistent initialization.

class Box {
    double width, height, depth;
    int boxNo;
    Box(double w, double h, double d, int num) {
        width = w;
        height = h;
        depth = d;
        boxNo = num;
    }
    Box() {
        width = height = depth = 0;
    }
    Box(int num) {
        this(); // Calls the no-argument constructor
        boxNo = num;
    }
    public static void main(String[] args) {
        Box box1 = new Box(1);
        System.out.println(box1.width);
    }
}

Output
0.0

Rules for Using this() in Constructors
Constructor calls must be the first statement in the constructor.
Recursive constructor calls are not allowed.
A constructor can call only one other constructor.

Invalid Example:

    Box(int num) {
    boxNo = num;
    this(); // Compile-time error
    }

Note:
Constructors can be overloaded like methods, but they do not have return types.
If any constructor is defined, Java does not generate a default constructor.
Constructor overloading improves object initialization flexibility.
Overloading is resolved at compile time.

Constructor Overloading vs Method Overloading
Feature: Constructor Overloading
Purpose: Initialize objects
Return type: Not allowed
Name:Same as class
Invocation:new keyword

Feature: Method Overloading
Purpose:Define multiple behaviors
Return type:Required
Name: Any valid method name
Invocation:Method call

Constructor Chaining in Java

PRIYA K — Fri, 19 Jun 2026 16:32:10 +0000

Read gfg

Constructor chaining is the process of calling one constructor from another constructor within the same class or from a parent class. It helps reduce code duplication and improves code readability by reusing existing constructor logic. Constructor chaining is achieved using the this() and super() keywords.
Uses this() for constructors within the same class.
Uses super() to call a parent class constructor.

Types of Constructor Chaining in Java**

Constructor Chaining Within the Same Class Using this()**

Constructor chaining within the same class occurs when one constructor calls another constructor of the same class using the this() keyword. It is mainly used to reuse initialization code between multiple constructors.
this() calls another constructor of the same class.
It must be written as the first statement in a constructor.

Rules of constructor chaining :
The this() expression should always be the first line of the constructor.
There should be at-least be one constructor without the this() keyword .
Constructor chaining can be achieved in any order.

What happens if we change the order of constructors?
Nothing, Constructor chaining can be achieved in any order

2. Constructor Chaining Using super() (Parent Class)

Constructor chaining between classes occurs when a child class constructor calls the parent class constructor using the super() keyword. It ensures that the parent class object is initialized before the child class object.

It must be the first statement in the child class constructor.
Used in inheritance to initialize superclass members.

Syntax

class Parent {
    Parent() {
     // parent constructor
     }
    }

    class Child extends Parent {
    Child() {
    super();
    // child constructor
     }
    }

Note : Similar to constructor chaining in same class, super() should be the first line of the constructor as super class's constructor are invoked before the sub class's constructor.

Constructor Chaining Using Initialization Block

An initialization block is a block of code that executes before constructors whenever an object is created. It is useful when the same code needs to run for multiple constructors.

Used to initialize common resources.
Multiple initialization blocks execute in the order they are defined.
NOTE: If there are more than one blocks, they are executed in the order in which they are defined within the same class

Advantages of Constructor Chaining

Avoids code duplication
Improves code readability
Makes constructor management easier
Provides better object initialization
Supports inheritance-based initialization

Map in Collections in Java

PRIYA K — Wed, 17 Jun 2026 12:29:19 +0000

https://www.w3schools.com/java/java_map.asp
https://www.tutorialspoint.com/java/java_map_interface.htm
https://www.programiz.com/java-programming/map
https://www.geeksforgeeks.org/java/map-interface-in-java/

In Java, the Map Interface is part of the java.util package and represents a collection of key-value pairs, where Keys should be unique, but values can be duplicated.
The Map interface of the Java collections framework provides the functionality of the map data structure.

It provides efficient retrieval, insertion, and deletion operations based on keys.
HashMap and LinkedHashMap allow one null key, and TreeMap does NOT allow null keys (if natural ordering is used).
Use ConcurrentHashMap for thread-safe operations, or Collections.synchronizedMap() to make an existing map synchronized.

The Map interface is a part of the Java Collections Framework and is used to store key-value pairs. Each key must be unique, but values can be duplicated.

In Java, elements of Map are stored in key/value pairs. Keys are unique values associated with individual Values.

A map cannot contain duplicate keys. And, each key is associated with a single value.

The Map interface maps unique keys to values. A key is an object that you use to retrieve a value at a later date.
Given a key and a value, you can store the value in a Map object. After the value is stored, you can retrieve it by using its key.
Several methods throw a NoSuchElementException when no items exist in the invoking map.
A ClassCastException is thrown when an object is incompatible with the elements in a map.

A NullPointerException is thrown if an attempt is made to use a null object and null is not allowed in the map.

An UnsupportedOperationException is thrown when an attempt is made to change an unmodifiable map.

Access those values using their corresponding keys.
Note: The Map interface maintains 3 different sets:
the set of keys
the set of values
the set of key/value associations (mapping).
Hence we can access keys, values, and associations individually.
We can access and modify values using the keys associated with them.

Common Map Methods
isEmpty() This method is used to check if a map is having any entry for key and value pairs. If no mapping exists, then this returns true.

hashCode() This method is used in Map Interface to generate a hashCode for the given map containing keys and values.

merge(K key, V value, BiFunction<? super V,? super V,? extends V> remappingFunction) If the specified key is not already associated with a value or is associated with null, associate it with the given non-null value.

put()

Adds or updates a key-value pair

put(K, V) - Inserts the association of a key K and a value V into the map. If the key is already present, the new value replaces the old value.
putAll() - Inserts all the entries from the specified map to this map.
putAll(Map) This method is used in Map Interface in Java to copy all of the mappings from the specified map to this map.
putIfAbsent(K, V) - Inserts the association if the key K is not already associated with the value V.Adds a mapping only if the key is not already mapped.

get()

Returns the value for a given key
get(Object) Returns the value for the given key, or null if not found.
get(K) - Returns the value associated with the specified key K. If the key is not found, it returns null.
getOrDefault(K, defaultValue) - Returns the value associated with the specified key K. If the key is not found, it returns the defaultValue.

getOrDefault(Object key, V defaultValue)    Returns the value to which the specified key is mapped, or defaultValue if this map contains no mapping for the key.

remove()

Removes the key and its value.
remove(Object) This method is used in Map Interface to remove the mapping for a key from this map if it is present in the map.

remove(K) - Removes the entry from the map represented by the key K.
remove(K, V) - Removes the entry from the map that has key K associated with value V.

containsKey()

Checks if the map contains the key
containsKey(K) - Checks if the specified key K is present in the map or not.Checks if a key exists in the map.
containsValue(V) - Checks if the specified value V is present in the map or not.Checks if a value exists in the map.

keySet()

Returns a set of all keys
Returns a set of all the keys present in a map.
Returns a set view of the keys in the map.
put(Object, Object) This method is used in Java Map Interface to associate the specified value with the specified key in this map.

values() - Returns a set of all the values present in a map.

Returns a collection view of the map’s values.
entrySet() - Returns a set of all the key/value mapping present in a map.Returns a set view of the map’s key-value pairs.
equals(Object) Compares two maps for equality.

replace(K, V) - Replace the value of the key K with the new specified value V.
replace(K, oldValue, newValue) - Replaces the value of the key K with the new value newValue only if the key K is associated with the value oldValue.

void clear( )

Removes all key/value pairs from the invoking map.

clear() This method is used in Java Map Interface to clear and remove all of the elements or mappings from a specified Map collection.

boolean containsKey(Object k)
Returns true if the invoking map contains k as a key. Otherwise, returns false.

boolean containsValue(Object v)
Returns true if the map contains v as a value. Otherwise, returns false.

Set entrySet( )
Returns a Set that contains the entries in the map. The set contains objects of type Map.Entry. This method provides a set-view of the invoking map.

boolean equals(Object obj)
Returns true if obj is a Map and contains the same entries. Otherwise, returns false.

Object get(Object k)
Returns the value associated with the key k.

int hashCode( )
Returns the hash code for the invoking map.

boolean isEmpty( )
Returns true if the invoking map is empty. Otherwise, returns false.

Set keySet( )
Returns a Set that contains the keys in the invoking map. This method provides a set-view of the keys in the invoking map.

Object put(Object k, Object v)
Puts an entry in the invoking map, overwriting any previous value associated with the key. The key and value are k and v, respectively. Returns null if the key did not already exist. Otherwise, the previous value linked to the key is returned.

void putAll(Map m)
Puts all the entries from m into this map.

Object remove(Object k)
Removes the entry whose key equals k.

int size( )
Returns the number of key/value pairs in the map.

size() This method is used to return the number of key/value pairs available in the map.

Collection values( )
Returns a collection containing the values in the map. This method provides a collection-view of the values in the map.

Classes that Implement Map
we cannot create objects from it.
These classes are defined in the collections framework and implemented in the Map interface.
The following are the classes that implement a Map to use the functionalities of a Map -
HashMap
EnumMap
LinkedHashMap
WeakHashMap
TreeMap

Interfaces that Extend Map
The Map interface is also extended by these subinterfaces:
The following are the interfaces that extend the Map interface -
SortedMap
NavigableMap
ConcurrentMap

How to use Map?
In Java, we must import the java.util.Map package in order to use Map. Once we import the package, here's how we can create a map.

// Map implementation using HashMap
Map<Key, Value> numbers = new HashMap<>();

In the above code, we have created a Map named numbers. We have used the HashMap class to implement the Map interface.
Key - a unique identifier used to associate each element (value) in a map
Value - elements associated by keys in a map

Map vs. Set vs. List
Feature:List
Duplicates allowed? Yes
Stores key-value pairs? No

Maintains order? Yes

Feature:Set
Duplicates allowed? No
Stores key-value pairs? No
Maintains order? No (unless using TreeSet or LinkedHashSet)

Feature:Map
Duplicates allowed? Keys: No Values: Yes
Stores key-value pairs? Yes
Maintains order? No (unless using TreeMap or LinkedHashMap)

Declaration of the Map interface

    public interface Map<K, V>

K -> Type of keys maintained by the map
V -> Type of mapped values

Creating Map Objects
Since a Map is an interface, we cannot create its object directly. We must use a class that implements it (e.g., HashMap).

    Map<String, Integer> hm = new HashMap<>();

import java.util.HashMap;
import java.util.Map;
public class Geeks{
    public static void main(String[] args){
        // Create a Map using HashMap
        Map<String, Integer> m = new HashMap<>();
        // Adding key-value pairs to the map
        m.put("Geek1", 1);
        m.put("Geek2", 2);
        m.put("Geek3", 3);
        System.out.println("Map elements: " + m);
    }
}

Output
Map elements: {Geek3=3, Geek2=2, Geek1=1}

Hierarchy of Map
It is part of the Java Collections Framework, and its key implementation classes include HashMap, LinkedHashMap, TreeMap, and Hashtable.

Note: Map does not extend the Collection interface and is used to efficiently store and retrieve data using keys.

A Map is useful when you want to associate a key (like a name or ID) with a value (like an age or description).

Common classes that implement Map:
Implemented Classes of Map Interface
Common classes that implement Map:
HashMap: Stores key-value pairs using hashing for fast access, insertion, and deletion.fast and unordered.
LinkedHashMap: Similar to HashMap but maintains the insertion order of key-value pairs.ordered by insertion.
TreeMap: Stores key-value pairs in sorted order using natural ordering or a custom comparator.sorted by key.
Hashtable: A synchronized Map implementation that doesn’t allow null keys or values.

Tip: Use a Map when you want to associate values with unique keys, like storing user IDs with names.

Operations on Map using HashMap
how to perform a few frequently used operations on a Map using the widely used HashMap class.

1. Adding Elements
Use the put() method to add elements to a Map. In HashMap, insertion order isn’t preserved, each element is stored based on its hash for faster access.

import java.util.*;
class Geeks {
    public static void main(String[] args) {
        // Default initialization of a Map using generics
        Map<Integer, String> hm1 = new HashMap<>();
        // Initialization of a Map (redundant type on right side unnecessary)
        Map<Integer, String> hm2 = new HashMap<>();
        // Inserting elements
        hm1.put(1, "Geeks");
        hm1.put(2, "For");
        hm1.put(3, "Geeks");
        // Inserting elements — no need to use new Integer()
        hm2.put(1, "Geeks");
        hm2.put(2, "For");
        hm2.put(3, "Geeks");
        System.out.println(hm1);
        System.out.println(hm2);
    }
}

Output
{1=Geeks, 2=For, 3=Geeks}
{1=Geeks, 2=For, 3=Geeks}

2. Changing Element
To update a value, use the put() method with the same key. The new value replaces the old one for that key.

import java.util.*;
class Geeks {
    public static void main(String args[])
    {
        // Initialization of a Map using Generics
        Map<Integer, String> hm1
            = new HashMap<Integer, String>();
        // Inserting the Elements
        hm1.put(new Integer(1), "Geeks");
        hm1.put(new Integer(2), "Geeks");
        hm1.put(new Integer(3), "Geeks");
        System.out.println("Initial Map: " + hm1);
        hm1.put(new Integer(2), "For");
        System.out.println("Updated Map: " + hm1);
    }
}

Output
Initial Map: {1=Geeks, 2=Geeks, 3=Geeks}
Updated Map: {1=Geeks, 2=For, 3=Geeks}

3. Removing Elements
To remove an element from the Map, we can use the remove() method. This method takes the key value and removes the mapping for a key from this map if it is present in the map.

import java.util.*;
class Geeks{
    public static void main(String args[]){
        // Initialization of a Map using Generics
        Map<Integer, String> hm1
            = new HashMap<Integer, String>();
        // Inserting the Elements
        hm1.put(new Integer(1), "Geeks");
        hm1.put(new Integer(2), "For");
        hm1.put(new Integer(3), "Geeks");
        hm1.put(new Integer(4), "For");
        System.out.println(hm1);
        hm1.remove(new Integer(4));
        System.out.println(hm1);
    }
}

Output
{1=Geeks, 2=For, 3=Geeks, 4=For}
{1=Geeks, 2=For, 3=Geeks}

4. Iterating through the Map
There are multiple ways to iterate through the Map. The most famous way is to use a for-each loop and get the keys. The value of the key is found by using the getValue() method.

import java.util.*;
class Geeks{
    public static void main(String args[]){
        // Initialization of a Map using Generics
        Map<Integer, String> hm1
            = new HashMap<Integer, String>();
        // Inserting the Elements
        hm1.put(new Integer(1), "Geeks");
        hm1.put(new Integer(2), "For");
        hm1.put(new Integer(3), "Geeks");
        for (Map.Entry mapElement : hm1.entrySet()) {
            int key = (int)mapElement.getKey();
            // Finding the value
            String value = (String)mapElement.getValue();
            System.out.println(key + " : " + value);
        }
    }
}

Output
1 : Geeks
2 : For
3 : Geeks

Set in Collections in Java

PRIYA K — Tue, 16 Jun 2026 23:29:53 +0000

https://www.w3schools.com/java/java_set.asp
https://www.geeksforgeeks.org/java/set-in-java/
https://www.tutorialspoint.com/java/java_set_interface.htm

programiz.com

A Set is a Collection that cannot contain duplicate elements. It models the mathematical set abstraction.

The Set interface contains only methods inherited from Collection and adds the restriction that duplicate elements are prohibited.

Set also adds a stronger contract on the behavior of the equals and hashCode operations, allowing Set instances to be compared meaningfully even if their implementation types differ.

The Set interface is a part of the Java Collection Framework, located in the java.util package.
It models the mathematical set abstraction.
It represents a collection of unique elements, meaning it does not allow duplicate values.
The Set interface contains only methods inherited from Collection and adds the restriction that duplicate elements are prohibited.

The Set interface of the Java Collections framework provides the features of the mathematical set in Java. It extends the Collection interface.

Set also adds a stronger contract on the behavior of the equals and hashCode operations, allowing Set instances to be compared meaningfully even if their implementation types differ.

The set interface does not allow duplicate elements.
It can contain at most one null value except TreeSet implementation which does not allow null.
The set interface provides efficient search, insertion, and deletion operations.

Set does not allow duplicates, and it does not preserve the order of elements (unless you're using TreeSet or LinkedHashSet).

Common classes that implement Set:

HashSet - fast and unordered
TreeSet - sorted set
LinkedHashSet - ordered by insertion

Use a Set when you need to store unique values only.

Classes that implement Set
Since Set is an interface, we cannot create objects from it.
In order to use functionalities of the Set interface, we can use these classes:
HashSet
LinkedHashSet
EnumSet
TreeSet
These classes are defined in the Collections framework and implement the Set interface.

Interfaces that extend Set
The Set interface is also extended by these subinterfaces:
SortedSet
NavigableSet

How to use Set?
In Java, we must import java.util.Set package in order to use Set.

// Set implementation using HashSet
Set<String> animals = new HashSet<>();

Here, we have created a Set called animals. We have used the HashSet class to implement the Set interface.

Set Operations
The Java Set interface allows us to perform basic mathematical set operations like union, intersection, and subset.

Union - to get the union of two sets x and y, we can use x.addAll(y)
Intersection - to get the intersection of two sets x and y, we can use x.retainAll(y)Set Operations
Subset - to check if x is a subset of y, we can use y.containsAll(x)

Common Set Methods

The Set interface includes all the methods of the Collection interface. It's because Collection is a super interface of Set.

Some of the commonly used methods of the Collection interface that's also available in the Set interface are:

add()

Adds an element if it's not already in the set.Adds an object to the collection.

addAll()
adds all the elements of the specified collection to the set

containsAll()
returns true if the set contains all the elements of the specified collection

toArray()
returns an array containing all the elements of the set

remove()

Removes the element from the set.
Removes a specified object from the collection.

removeAll()
removes all the elements from the set that is present in another specified set

contains()

Checks if the set contains the element.
Returns true if a specified object is an element within the collection.
returns true if the set contains the specified element

size()

Returns the number of elements in the collection.
returns the length (number of elements) of the set

clear()

Removes all elements.Removes all objects from the collection.

retainAll()
retains all the elements in the set that are also present in another specified set

isEmpty( )
Returns true if the collection has no elements.

hashCode()
returns a hash code value (address of the element in the set)

iterator( )
Returns an Iterator object for the collection, which may be used to retrieve an object.
returns an iterator that can be used to access elements of the set sequentially

Set vs. List
List Set
Allows duplicates Does not allow duplicates
Maintains order Does not guarantee order
Access by index No index-based access

Declaration of Set Interface

    public interface Set<E> extends Collection <E>

import java.util.HashSet;
import java.util.Set;
public class Geeks {
    public static void main(String args[]) 
    {
        // Create a Set using HashSet
        Set<String> s = new HashSet<>();
        // Displaying the Set
        System.out.println("Set Elements: " + s);
    }
}

Explanation: In the above example, HashSet will appear as an empty set, as no elements were added. The order of elements in HashSet is not guaranteed, so the elements will be displayed in a random order if any are added.

Hierarchy of Set interface

Classes that implement the Set interface

HashSet: A set that stores unique elements without any specific order, using a hash table and allows one null element.
EnumSet : A high-performance set designed specifically for enum types, where all elements must belong to the same enum.
LinkedHashSet: A set that maintains the order of insertion while storing unique elements.
TreeSet: A set that stores unique elements in sorted order, either by natural ordering or a specified comparator.

Creating Set Objects

Since Set is an interface, objects cannot be created of the typeset. We always need a class that implements this interface in order to create an object. it is possible to restrict the type of object that can be stored in the Set. This type-safe set can be defined as:

    // Obj is the type of the object to be stored in Set 
    Set<Obj> set = new HashSet<Obj> ();

Performing Various Operations on Set

Set interface provides commonly used operations to manage unique elements in a collection.

1. Adding Elements
To add elements to a Set in Java, use the add() method.

import java.util.*;
// Main class
class Geeks {
    public static void main(String[] args)
    {
        Set<String> s = new HashSet<String>();
        s.add("B");
        s.add("B");
        s.add("C");
        s.add("A");
        System.out.println(s);
    }
}

Output
[A, B, C]

2. Accessing the Elements
After adding the elements, if we wish to access the elements, we can use inbuilt methods like contains().

import java.util.*;
class Geeks {
    public static void main(String[] args)
    {
        Set<String> h = new HashSet<String>();
        h.add("A");
        h.add("B");
        h.add("C");
        h.add("A");
        System.out.println("Set is " + h);
        String s = "D";
        System.out.println("Contains " + s + " " + h.contains(s));
    }
}

Output
Set is [A, B, C]
Contains D false

3. Removing Elements
The values can be removed from the Set using the remove() method.

import java.util.*;
class Geeks {
    public static void main(String[] args)
    {
        // Declaring object of Set of type String
        Set<String> h = new HashSet<String>();
        // Elements are added using add() method, Custom input elements
        h.add("A");
        h.add("B");
        h.add("C");
        h.add("B");
        h.add("D");
        h.add("E");
        System.out.println("Initial HashSet " + h);
        // Removing custom element using remove() method
        h.remove("B");
        System.out.println("After removing element " + h);
    }
}

Output
Initial HashSet [A, B, C, D, E]
After removing element [A, C, D, E]

4. Iterating elements
There are various ways to iterate through the Set. The most famous one is to use the enhanced for loop.

import java.util.*;
class Geeks {
public static void main(String[] args)
{
// Creating object of Set and declaring String type
Set h = new HashSet();
// Adding elements to Set using add() method, Custom input elements
h.add("A");
h.add("B");
h.add("C");
h.add("B");
h.add("D");
h.add("E");
// Iterating through the Set via for-each loop
for (String value : h)
// Printing all the values inside the object
System.out.print(value + ", ");
System.out.println();
}
}

Output
A, B, C, D, E,

Methods of Set Interface

add(element)

Adds element if not already present. Returns true if added.

addAll(collection)

Adds all elements from the given collection.

clear()
Removes all elements from the set.

contains(element)

Checks if the set contains the specified element.

containsAll(collection)
Checks if the set contains all elements from the given collection.

hashCode()

Returns the hash code of the set.

isEmpty()

This method is used to check whether the set is empty or not.

iterator()

This method is used to return the iterator of the set.

remove(element)
Removes the specified element from the set.

removeAll(collection)

Removes all elements in the given collection from the set.

retainAll(collection)

Retains only elements present in the given collection.

size()

Returns the number of elements in the set.

toArray()

This method is used to form an array of the same elements as that of the Set.

Set Interface Examples

Set has its implementation in various classes like HashSet, TreeSet, LinkedHashSet.

Example to Implement Set Using HashSet

import java.util.HashSet;
import java.util.Set;
public class SetDemo {
  public static void main(String args[]) { 
      int count[] = {34, 22,10,60,30,22};
      Set<Integer> set = new HashSet<>();
      try {
         for(int i = 0; i < 5; i++) {
            set.add(count[i]);
         }
         System.out.println(set);
      }
      catch(Exception e) {}
   }
}

Output
[34, 22, 10, 60, 30]

Example to Implement Set Using TreeSet

import java.util.HashSet;
import java.util.Set;
import java.util.TreeSet;
public class SetDemo {
  public static void main(String args[]) { 
      int count[] = {34, 22,10,60,30,22};
      Set<Integer> set = new HashSet<>();
      try {
         for(int i = 0; i < 5; i++) {
            set.add(count[i]);
         }
         System.out.println(set);

         TreeSet<Integer> sortedSet = new TreeSet<>(set);
         System.out.println("The sorted list is:");
         System.out.println(sortedSet);
         System.out.println("The First element of the set is: "+ (Integer)sortedSet.first());
         System.out.println("The last element of the set is: "+ (Integer)sortedSet.last());
      }
      catch(Exception e) {}
   }
}

Output
[34, 22, 10, 60, 30]

The sorted list is:
[10, 22, 30, 34, 60]
The First element of the set is: 10
The last element of the set is: 60

Example to Implement Set Using LinkedHashSet

import java.util.LinkedHashSet;
import java.util.Set;
public class SetDemo {
  public static void main(String args[]) { 
      int count[] = {34, 22,10,60,30,22};
      Set<Integer> set = new LinkedHashSet<>();
      try {
         for(int i = 0; i < 5; i++) {
            set.add(count[i]);
         }
         System.out.println(set);
      }
      catch(Exception e) {}
   }
}

Output
[34, 22, 10, 60, 30]

Comparable vs Comparator in Java

PRIYA K — Tue, 16 Jun 2026 16:30:23 +0000

gfg

Comparable defines the natural ordering of a class's own objects by modifying the class itself, while Comparator defines custom, external sorting logic without altering the original class.
In Java, both Comparable and Comparator interfaces are used for sorting objects. The main difference between Comparable and Comparator is:

Comparable: It is used to define the natural ordering of the objects within the class.
Comparator: It is used to define custom sorting logic externally.

Comparable
Definition:It defines natural ordering within the class.
Method:compareTo()
Implementation:It is implemented in the class.
Sorting Criteria:Natural order sorting
Package:java.lang
Method:compareTo(T o)
Location:Implemented directly inside the target class.
Sorting Options:Provides exactly one default sorting sequence.
Modifies Class?:Yes, requires altering the class source code.
Invocation:Collections.sort(list)
Usage:It is used for a single sorting order.

Comparator
Definition:It defines external or custom sorting logic.
Implementation:It is implemented in a separate class.
Method:compare()
Sorting Criteria:Custom order sorting
Package:java.util
Method:compare(T o1, T o2)
Location:Implemented in separate classes or inline lambdas.
Sorting Options:Provides multiple dynamic sorting strategies.
Modifies Class?:No, works on classes you cannot modify.
Invocation:Collections.sort(list, comparator)
Usage:It is used for a multiple sorting order.

Using Comparable (Natural Ordering) The target class implements Comparable and overrides compareTo. It takes one explicit argument to compare with this.

import java.util.*;

// Modifies the class itself
class Product implements Comparable<Product> {
    private String name;
    private int price;

    public Product(String name, int price) {
        this.name = name;
        this.price = price;
    }

    public int getPrice() { return price; }
    public String getName() { return name; }

    // Natural sorting by price (ascending)
    @Override
    public int compareTo(Product other) {
        return Integer.compare(this.price, other.price);
    }
}

Usage:

List<Product> list = new ArrayList<>();
Collections.sort(list); // Automatically uses compareTo()

2. Using Comparator (Custom Ordering)
The sorting logic is separate from the entity. It takes two arguments to compare them against each other. It qualifies as a functional interface, meaning you can write it cleanly with Java 8+ lambdas.

// Option A: Traditional separate class approach
class NameComparator implements Comparator<Product> {
    @Override
    public int compare(Product p1, Product p2) {
        return p1.getName().compareTo(p2.getName());
    }
}

// Option B: Modern, cleaner Lambda or Method Reference approach
Comparator<Product> lambdaByName = (p1, p2) -> p1.getName().compareTo(p2.getName());
Comparator<Product> simpleByPrice = Comparator.comparing(Product::getPrice);

Usage

List<Product> list = new ArrayList<>();
// Pass both the list and your custom rule
Collections.sort(list, new NameComparator()); 
list.sort(Comparator.comparing(Product::getName));